package practicacupfinal;

import es.ucm.fdi.plg.evlib.Atribucion;
import es.ucm.fdi.plg.evlib.Atributo;
import es.ucm.fdi.plg.evlib.SemFun;
import es.ucm.fdi.plg.evlib.TAtributos;
import java.util.ArrayList;
import java.util.Iterator;
import semantica.*;
import semantica.tipos.*;

import semantica.tipos.TipoTupla.*;

class Asignacion implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return args[0].valor();
    }  
}
                        class AsignacionP implements SemFun{


                            @Override
                            public Object eval(Atributo... args) {
                              Object a = args[0].valor();
                                return a;
                            }  
                        }
class AsignacionL implements SemFun{


    @Override
    public Object eval(Atributo... args) {
      TablaDeSimbolos ts= (TablaDeSimbolos) args[0].valor();
        return ts;
    }  
}

class Asignacion0 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return 0;
    }
}

class Asignacion1 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return 1;
    }
}

class Asignacion2 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return 2;
    }
}

class Asignacion3 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return 3;
    }
}

class AsignacionSuma1 implements SemFun{

    @Override
    public Object eval(Atributo... args){
        return (int)args[0].valor() + 1;
    }
}

class AsignacionSuma1P implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        Object o = args[0].valor();
        return (int)args[0].valor() + 1;
    }
}
class AsignacionSuma2 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + 2;
    }
}

class AsignacionSuma3 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + 3;
    }
}

class AsignacionSuma13 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + 13;
    }
}

class AsignacionSuma14 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + 14;
    }
}

                class AsignacionSuma4 implements SemFun{

                    @Override
                    public Object eval(Atributo... args) {
                        return (int)args[0].valor() + 4;
                    }
                }

class AsignacionSuma5 implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + 5;
    }
}


class AsignacionMenos implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        String a = "-";
        a +=args[0].valor();
       
    	return a;
    }
    
}

class CreaNatural implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaNatural();
    }

}

class CreaBool implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaBoolean();
    }
}

class CreaInt implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaInteger();
    }
}

 class CreaChar implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaCharacter();
    }
}

 class CreaFloat implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaFloat();
    }
}

class ClaseConst implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return "const";
    }
}

class CodVacio implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.creaCod();
     }
}
class CodMostrarErroresVacio implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return "";
     }

}


class CreaTs implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaTS();
     }
}

class CreaErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return semantica.Semantica.creaErrores();
     }
}

class AsignacionTrue implements SemFun{
    @Override
    public Object eval(Atributo... args) {       
        return "true";
     }
}

class AsignacionFalse implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return "false";
    }
}
class InicializacionTipoConstante implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        Tipo t = (Tipo)args[0].valor();
        String num = (String)args[1].valor();
        try {
            if (t.getTipo().equals("natural")) ((TipoNatural)t).setValor(Integer.parseInt(num));
            if (t.getTipo().equals("integer")) ((TipoInteger)t).setValor(Integer.parseInt(num));
            if (t.getTipo().equals("character")) ((TipoCharacter)t).setValor(num.charAt(1));
            if (t.getTipo().equals("float")) ((TipoFloat)t).setValor(Float.parseFloat(num));
            if (t.getTipo().equals("boolean")) ((TipoBoolean)t).setValor(Boolean.getBoolean(num));
        } catch (Exception e) {};

        return Semantica.tipoDe(t, num);
     }
}
  
class AsignacionCodConstante implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        Tipo tipo = (Tipo)args[0].valor();
        String num = (String)args[1].valor();
        ArrayList<String> a = Semantica.creaCod();
        a.add("apila("+ Semantica.valorDe(tipo, num)+ ")");
        
        return a;
     }
}

class ErrorTipoMostrarErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       String errores = "";       
       String filaCol = (String)args[0].valor();
       Tipo tipo = (Tipo)args[1].valor();
       String valor = (String)args[2].valor();
       String id = (String)args[3].valor();
        
       if (!Semantica.esTipoBasico(tipo))
            errores += filaCol + " Error: El tipo de la constante '" + id + " no es de tipo basico \n";
       else if (Semantica.tipoDe(tipo, valor).equals("errorTipo"))
            errores += filaCol + " Error: Al tipo '" + tipo.getTipo() + "' de la constante '" + id + " no se le puede asignar el valor '" + valor + "'\n";
          
       return errores;
       
     }
}

class CodApilaValor implements SemFun{
    @Override
    public Object eval(Atributo... args) {       
        String num = (String)args[0].valor();
        ArrayList<String> a = Semantica.creaCod();
        a.add("apila("+ num+ ")");

        return a;
     }
}

class CodApilaCharacter implements SemFun{
    @Override
    public Object eval(Atributo... args) {       
        String character  = (String)args[0].valor();
        ArrayList<String> a = Semantica.creaCod();
        
        a.add("apila("+ (int)character.charAt(1) + ")");

        return a;
     }
}

class CodApilaTrue implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> a = Semantica.creaCod();
        a.add("apila(1)");
        return a;
     }
}
class CodApilaFalse implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> a = Semantica.creaCod();
        a.add("apila(0)");
        return a;
     }
}
class AsignacionCodDecConst implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String s =  "desapila_dir("  + (((TablaDeSimbolos)args[1].valor()).getDir((String)args[2].valor()) ) + ")";
        return  Semantica.concatenaCod((ArrayList<String>) args[0].valor(), s , 
                (ArrayList<Boolean>) args[3].valor(), (Tipo) args[4].valor());
     }
}

class AsignacionTSDecConsts implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       return Semantica.creaTS((String)args[0].valor(),(String)args[1].valor(),(Tipo)args[2].valor(),2);     
    }
 }

class UnirDosTipos implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirTipos((Tipo) args[0].valor(), (Tipo) args[1].valor());
    }
}

class UnirTresTipos implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirTipos((Tipo) args[0].valor(), (Tipo) args[1].valor(), (Tipo) args[2].valor());
    }
}

class UnirCuatroTipos implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirTipos((Tipo) args[0].valor(), (Tipo) args[1].valor(), (Tipo) args[2].valor(), 
                (Tipo) args[3].valor());
    }
}
class UnirCincoTipos implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirTipos((Tipo) args[0].valor(), (Tipo) args[1].valor(), (Tipo) args[2].valor(), 
               (Tipo) args[3].valor(),(Tipo) args[4].valor());

    }
}
class CopiaErroresOrDuplicado implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[2].valor();
        boolean duplicado = ((TablaDeSimbolos)args[1].valor()).existeId(id);
        return  Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), duplicado ,0);
    }
}     

class CopiaMostrarErroresOrDuplicado implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[2].valor();
        String filaCol = (String)args[3].valor();
        boolean duplicado = ((TablaDeSimbolos)args[1].valor()).existeId(id);
        
        if (duplicado)
            return (String) args[0].valor() + filaCol + " Error: Identificador duplicado '" + id + "'\n";
        else return (String) args[0].valor();
    }
}      


class UnirErroresOrDuplicado implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[3].valor();
        boolean duplicado = ((TablaDeSimbolos)args[2].valor()).existeId(id);
        
        ArrayList<Boolean> errores = Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor());
        return  Semantica.unirErrores(errores, duplicado , 0);
    }
}

class UnirMostrarErroresOrDuplicado implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[3].valor();
        String filaCol = (String)args[4].valor();
        boolean duplicado = ((TablaDeSimbolos)args[2].valor()).existeId(id);
        String errores = (String) args[0].valor() + (String) args[1].valor();
        
        if (duplicado)
            return errores + filaCol + " Error: Identificador duplicado '" + id + "'\n";
        else 
            return errores;
    }
}

class SumaDirConTam implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return   (int) args[0].valor() + Semantica.tamDe((Tipo)args[1].valor(), (String)args[2].valor());
    }
}

class DirConTam implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.tamDe((Tipo)args[0].valor(), (String)args[1].valor());
    }
}

class AnadirTS implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.creaTS((TablaDeSimbolos)args[0].valor(), (String)args[2].valor(), (String)args[3].valor(), 
                 (ArrayList<Boolean>)args[1].valor(), (Tipo)args[4].valor(),(int)args[5].valor());
    }
}      

class AnadirTSTipo implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.creaTS((TablaDeSimbolos)args[0].valor(), (String)args[2].valor(),
                 (String)args[3].valor(), (ArrayList<Boolean>)args[1].valor(), (Tipo)args[4].valor(),0);
    }
}

class Concatena2CodYDesapila implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String s =  "desapila_dir("  + (((TablaDeSimbolos)args[2].valor()).getDir((String)args[3].valor()) ) + ")";

        return  Semantica.concatenaCod((ArrayList<String>) args[0].valor(), (ArrayList<String>) args[1].valor(),s , 
                (ArrayList<Boolean>) args[4].valor(), (Tipo) args[5].valor());
    }
}

class ConcatenaDosCod implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> cod = new ArrayList<String>();
        cod.addAll((ArrayList<String>) args[0].valor());
        cod.addAll((ArrayList<String>) args[1].valor());
        return cod;
    }
}

class CopiaErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.copiaErrores((ArrayList<Boolean>) args[0].valor());
    }
}

class CreaTipo implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return new Tipo();
    }
}

class CopiaCodigo implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.copiaCod((ArrayList<String>)args[0].valor(), 
                 (ArrayList<Boolean>)args[1].valor(), (Tipo)args[2].valor());
    }
}


class ClaseVar implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "var";
     }
}
class ClaseValor implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "valor";
     }
}
class ClaseTipo implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "tipo";
     }
}

class ClaseSubprograma implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "proc";
     }
}

class CreaCodMen implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("menor");
       return al;
    }
}

class CreaCodMay implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("mayor");
       return al;
    }
}

class CreaCodMenIgual implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("menorIgual");
       return al;
    }
}

class CreaCodMayIgual implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("mayorIgual");
       return al;
    }
}

class CreaCodIgual implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("igual");
       return al;
    }
}

class CreaCodNoIgual implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("distinto");
       return al;
    }
}

class CreaCodMas implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("suma");
       return al;
    }
}

class CreaCodMenos implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("resta");
       return al;
    }
}

class CreaCodOr implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("or");
       return al;
    }
}	

class CreaCodMul implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("multiplica");
       return al;
    }
}

class CreaCodDiv implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("divide");
       return al;
    }
}

class CreaCodMod implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("modulo");
       return al;
    }
}

class CreaCodAnd implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("and");
       return al;
    }
}	

class CreaCodDespDer implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("desplazarDer");
       return al;
    }
}

class CreaCodDespIzq implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("desplazarIzq");
       return al;
    }
}


class CreaCodNot implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("not");
       return al;
    }
}

class CreaCodMenosUnario implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("negativo");
       return al;
    }
}

class CreaCodCastNot implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("negativo");
       return al;
    }
}

class CreaCodCastChar implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("(char)");
       return al;
    }
}


class CreaCodCastFloat implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("(float)");
       return al;
    }
}

class CreaCodCastInt implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("(int)");
       return al;
    }
}

class CreaCodCastNat implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("(nat)");
       return al;
    }
}

class UnirDosErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor());
    }
}

class UnirMostrarDosErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  (String) args[0].valor() + (String) args[1].valor();
    }
}

class UnirTresErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor(),
                (ArrayList<Boolean>) args[2].valor());
    }
}

class UnirCuatroErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor(),
                (ArrayList<Boolean>) args[2].valor(), (ArrayList<Boolean>) args[3].valor());
    }
}
class UnirCincoErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor(),
                (ArrayList<Boolean>) args[2].valor(), (ArrayList<Boolean>) args[3].valor(),(ArrayList<Boolean>) args[4].valor());
    }
}
class UnirMostrarCincoErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       Object a = args[0].valor();
        Object asa = args[1].valor();
        Object adf = args[2].valor();
        Object ra = args[3].valor();
        Object afdgf = args[4].valor();
        return (String) args[0].valor() + (String) args[1].valor() + (String) args[2].valor() + (String) args[3].valor() + 
                (String) args[4].valor();
    }
}

class ConcatenaCodProg implements SemFun{
    @Override
    public Object eval(Atributo... args) {
 //dependencias(prog.a("cod"), constantes.a("cod"),subprogramas.a("cod"),variables.a("dir"),subprogramas.a("etq"),instrucciones.a("cod"),prog.a("err"),prog.a("tipo"));
        ArrayList<String> cod = new ArrayList<String>();
        cod.add("apila(2)");
        cod.add("desapila_dir(1)");
        cod.addAll((ArrayList<String>) args[0].valor());
        
        if ((int) args[2].valor() == 2) cod.add("apila(" + ((int) args[2].valor()) +  ")"); //por que no hay ni vars ni consts
        else cod.add("apila(" + ((int) args[2].valor() -1) +  ")");  // -1 xq tiene q apuntar a la ultima variable o const
        cod.add("desapila_dir(0)");
        cod.add("ir_a(" + (int) args[3].valor() + ")");
        cod.addAll((ArrayList<String>) args[1].valor());
            
        
        return  Semantica.concatenaCod(cod, (ArrayList<String>) args[4].valor(), "stop",
                (ArrayList<Boolean>) args[5].valor(), (Tipo) args[6].valor());
    }
}  

class ConcatenaCodInsts implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        return  Semantica.concatenaCod((ArrayList<String>) args[0].valor(), (ArrayList<String>) args[1].valor(),
                (ArrayList<Boolean>) args[2].valor(), (Tipo) args[3].valor());
    }
}  

// puede que haga falta while ref
class TipoDeIdConTS implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.tipoDe((String)args[0].valor(),((TablaDeSimbolos)args[1].valor()));
    }
}  

// puede que haga falta while ref
class TipoInstOut implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        Tipo tipo = (Tipo) args[0].valor();
        TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor();
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        if (Semantica.esTipoBasico(tipo)) return tipo; // si era tipoError ya me lo comprueba
        else return new TipoError();
    }
}  

// puede que haga falta while ref
class TipoInstIn implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       Tipo tipo = (Tipo) args[0].valor();
       TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor();
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        if (Semantica.esTipoBasico(tipo)) return tipo;
        else return new TipoError();
    }
}  



// puede q haga falta while ref
class DameTipoDeIdConTS implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor();
        Tipo tipo = ts.getTipo((String)args[0].valor());
        
        return tipo;
    }
}  

class CreaErroresTipoIdentificador implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        boolean noExisteId = !((TablaDeSimbolos)args[1].valor()).existeId((String) args[0].valor());
        return Semantica.unirErrores(Semantica.creaErrores(), noExisteId, 1);
    }
}  

class CreaMostrarErroresTipoIdentificador implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor(); 
        String id = (String) args[0].valor();
        String filaCol = (String)args[2].valor();
        Tipo tipo = (Tipo)args[3].valor();
        String errores = "";
        
         if (!ts.existeId(id))
            errores += filaCol + " Error: Tipo identificador  '" + (String) args[0].valor() + "'" + "no existe \n";
         if (ts.esConst(id))
            errores += filaCol + " Error: El identificador  '" + (String) args[0].valor() + "'" + " es una constante y no se puede usar como tipo \n";
         
         
         return errores;
         
    }
}  

class CreaArray implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return Semantica.creaArray(Integer.parseInt((String)args[0].valor()), (Tipo)args[1].valor());
    }
}  

class CreaArrayIdentificador implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        int tam = ((TablaDeSimbolos)args[0].valor()).getValorNatural((String)args[1].valor());
        return Semantica.creaArray(tam, (Tipo)args[2].valor());
    }
}  

class CreaErroresTipoArrayIdentificador implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String) args[1].valor();
        boolean noExisteId = !((TablaDeSimbolos)args[2].valor()).existeId(id);
        boolean noEsConstante = !((TablaDeSimbolos)args[2].valor()).esConst(id);
        boolean noEsNatural = !((TablaDeSimbolos)args[2].valor()).esNatural(id);
        ArrayList<Boolean> errores = Semantica.copiaErrores((ArrayList<Boolean>) args[0].valor());

        errores.set(1, errores.get(1) | noExisteId);
        errores.set(2, errores.get(2) | noEsConstante);
        errores.set(3, errores.get(3) | noEsNatural);
        return errores;
    }
}  

class CreaMostrarErroresTipoArrayIdentificador implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String) args[1].valor();
        boolean noExisteId = !((TablaDeSimbolos)args[2].valor()).existeId(id);
        boolean noEsConstante = !((TablaDeSimbolos)args[2].valor()).esConst(id);
        boolean noEsNatural = !((TablaDeSimbolos)args[2].valor()).esNatural(id);
        String errores = (String) args[0].valor();
        String filaCol = (String)args[3].valor();
        
        if (noExisteId)
            errores += filaCol + " Error: Array identificador '" + id + "'" + " no existe \n";
        if (noEsConstante)
            errores += filaCol + " Error: La creacion del array con '" + id + "'" + " no es una constante \n";
        if (noEsNatural)
            errores += filaCol + " Error: La creacion del array con '" + id + "'" + "no es un natural '\n";
        
        return errores;
    }
}  


class DameTamTipo implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        return ((Tipo)args[0].valor()).getTam();
    }
}  

class SumaDespConTamTipo implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return (int)args[0].valor() + ((Tipo)args[1].valor()).getTam();
    }
}  

class PrimerCampoTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<ContenidoTupla> campos = new ArrayList<ContenidoTupla>();
        ContenidoTupla campo = new ContenidoTupla((Tipo)args[0].valor(),0);
        campos.add(campo);

        return campos;
    }
}

class AnadirCampoTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<ContenidoTupla> campos = new ArrayList<ContenidoTupla>((ArrayList<ContenidoTupla>)args[0].valor());
        int desp = (int)args[2].valor();
        ContenidoTupla campo = new ContenidoTupla((Tipo)args[1].valor(),desp);
        campos.add(campo);          
        return campos;
    }
}

class CreaTuplaVacia implements SemFun{
    @Override
    public Object eval(Atributo... args){ 
        return Semantica.creaTuplaVacia();
    }
}

class CreaTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList <ContenidoTupla> campos = (ArrayList <ContenidoTupla>)args[0].valor();
        ArrayList<Boolean> err = (ArrayList <Boolean>)args[1].valor();
        Tipo tipo = (Tipo)args[2].valor();
        return Semantica.creaTupla(campos, err, tipo);
    }
}

class ConcatenaCodigoDeclaraciones implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> cod = new ArrayList<String>();
        cod.add("apila(2)");
        cod.add("desapila_dir(1)");
        cod.addAll((ArrayList<String>) args[0].valor());
        //cod.addAll((ArrayList<String>) args[1].valor());
        if ((int) args[2].valor() == 2) cod.add("apila(" + ((int) args[2].valor()) +  ")"); //por que no hay ni vars ni consts
        else cod.add("apila(" + ((int) args[2].valor() -1) +  ")");  // -1 xq tiene q apuntar a la ultima variable o const
        cod.add("desapila_dir(0)");
        cod.add("ir_a(" + (int) args[3].valor() + ")");
        cod.addAll((ArrayList<String>) args[1].valor());
        return cod;
    }
} 

class CreaCodSwap1 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("swap1");
       return al;
    }
}	

class CreaCodSwap2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       ArrayList<String> al = new ArrayList<String>();
       al.add("swap2");
       return al;
    }
}

class CopiaErroresInstsIn implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String) args[1].valor();
        TablaDeSimbolos ts =(TablaDeSimbolos)args[2].valor();
        Tipo tipo = (Tipo) args[3].valor(); //desig.tipo
        
        boolean asignacionConstante = ts.esConst(id); //Error 4
        boolean noTipoBasicoIn = !Semantica.esTipoBasico(tipo); //Error5

        ArrayList<Boolean> errores = Semantica.copiaErrores((ArrayList<Boolean>) args[0].valor());
        errores.set(5, errores.get(5) | noTipoBasicoIn);
        errores.set(4, errores.get(4) | asignacionConstante);

        return errores;  
        
    }
}  

class CodDesigIden implements SemFun{
    @Override
    public Object eval(Atributo... args) {

       TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor();
       int dir = ts.getDir((String) args[0].valor());
       String nivel = ts.dameNivel((String) args[0].valor());
       String clase = ts.dameClase((String) args[0].valor());
       ArrayList<String> cod = Semantica.creaCod();
       
       if (nivel.equals("global"))
           cod.add("apila(" + dir + ")");
       else if (nivel.equals("local")){
           cod.add("apila(" + dir + ")"); 
           cod.add("apila_dir(1)");
           cod.add("suma");
           if (clase.equals("pvar")) 
               cod.add("apila_ind");
       }

       return cod;
    }
}  


class EtqDesigIden implements SemFun{
    @Override
    public Object eval(Atributo... args) {

       TablaDeSimbolos ts = (TablaDeSimbolos)args[2].valor();
       int etq = (int)args[0].valor();
       String nivel = ts.dameNivel((String) args[1].valor());
       String clase = ts.dameClase((String) args[1].valor());
       
       if (nivel.equals("global"))
           etq += 1;
       else if (nivel.equals("local")){
           etq += 3;
           if (clase.equals("pvar"))
               etq += 1;
       }

       return etq;
    }
}  
                
class CreaErroresDesigIden implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        boolean noExisteId = !((TablaDeSimbolos)args[1].valor()).existeId((String) args[0].valor());

        ArrayList<Boolean> errores = Semantica.creaErrores();

        errores.set(1, errores.get(1) | noExisteId);

        return errores;
    }
}  

class EtqInstIn implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        int etq =  (int)args[0].valor() + 2;

        return etq ;
    }
} 

// puede q haga falta un while ref
class CodInstIn implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        ArrayList<String> cod = Semantica.creaCod();
        cod.addAll((ArrayList<String>)args[0].valor());
        Tipo tipo = (Tipo)args[1].valor();
        TablaDeSimbolos ts = (TablaDeSimbolos) args[2].valor();
        
         while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        cod.add("read(" + tipo.getTipo() + ")");
        cod.add("desapila_ind");

        return cod;
    }
} 
    
class TipoResultante2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        Tipo tipo1 = (Tipo)args[1].valor();
        Tipo tipo2 = (Tipo)args[2].valor();
        ArrayList<String> op = (ArrayList<String>)args[0].valor();
        
        Tipo tipoResultante = Semantica.consultarTipoResultante(tipo1.getTipo() + 
                tipo2.getTipo() + (String)op.get(0));

        return tipoResultante;
    }
} 

class TipoResultante1 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> op = (ArrayList<String>)args[0].valor();
        Tipo tipo = (Tipo)args[1].valor();
        
        Tipo tipoResultante = Semantica.consultarTipoResultante(tipo.getTipo() + (String)op.get(0));

        return tipoResultante;
    }
}

class CodExp implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        ArrayList<String> cod = Semantica.creaCod();
        boolean esdesig1 =(boolean)args[3].valor();
        boolean esdesig2 =(boolean)args[4].valor();

        cod.addAll((ArrayList<String>)args[0].valor());
        if (esdesig1) cod.add("apila_ind");
        
        cod.addAll((ArrayList<String>)args[1].valor());
        if (esdesig2) cod.add("apila_ind");
        
        cod.addAll((ArrayList<String>)args[2].valor());

        return cod;
    }
} 
class CodExpNivel4 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        ArrayList<String> cod = Semantica.creaCod();
        boolean esdesig1 =(boolean)args[2].valor();
        Tipo ti = (Tipo)args[3].valor();
        
        cod.addAll((ArrayList<String>)args[0].valor());
        if (esdesig1) cod.add("apila_ind");
        
        ArrayList<String> op = (ArrayList<String>)args[1].valor();
        
        if(op.get(0).equals(("(nat)")) || op.get(0).equals(("(int)"))|| op.get(0).equals(("(float)")) ||op.get(0).equals(("(char)")))
         cod.add("casting("+ti.getTipo()+")");
          
        else 
          cod.addAll((ArrayList<String>)args[1].valor());

        return cod;
    }
} 

class SumaEtqExp implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        int etq = (int)args[0].valor()+1;

        if ((boolean)args[1].valor()) etq += 1;
        if ((boolean)args[2].valor()) etq += 1;

        return etq;
    }
} 


class Irf_irv_OpOr implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String op = ((ArrayList<String>)args[0].valor()).get(0);
        int irv_irf = (int) args[1].valor();
        int etq = (int) args[2].valor();
        boolean esDesig = (boolean) args[3].valor();
        
        if (esDesig) etq += 1;
        if (op.equals("or")) return irv_irf;
        else return etq;    
    }
} 

class Irf_irv_OpOrSuma2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {                    
        String op = ((ArrayList<String>)args[0].valor()).get(0);
        int etq = (int) args[1].valor();
        boolean esDesig = (boolean) args[2].valor();
        
        if (esDesig) etq += 1;
        if (op.equals("or")) return etq + 2;
        else return etq;    
    }
} 
class Irf_irv_OpAnd implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String op = ((ArrayList<String>)args[0].valor()).get(0);
        int irv_irf = (int) args[1].valor();
        int etq = (int) args[2].valor();
        boolean esDesig = (boolean) args[3].valor();
        
        if (esDesig) etq += 1;
        if (op.equals("and")) return irv_irf;
        else return etq;   
        
    }
} 

class Irf_irv_OpAndSuma2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String op = ((ArrayList<String>)args[0].valor()).get(0);        
        int etq = (int) args[1].valor();
        boolean esDesig = (boolean) args[2].valor();
        
        if (esDesig) etq += 1;
        if (op.equals("and")) return etq + 2;
        else return etq;    
    }
} 

class EtqhSuma3 implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        String op = ((ArrayList<String>)args[1].valor()).get(0);
        if (op.equals("or")) return (int) args[0].valor()+3;
        else return (int) args[0].valor();

    }
} 

class EtqhSuma3ExpNivel2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        String op = ((ArrayList<String>)args[1].valor()).get(0);
        if (op.equals("and")) return (int) args[0].valor()+3;
        else return (int) args[0].valor();
 
    }
} 
class EtqExpnivel1 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> x = (ArrayList<String>) args[3].valor();
        String op =  x.get(0);
        int etq = (int)args[0].valor();
        if (!op.equals("or")) etq++;

        if ((boolean)args[1].valor()) etq += 1;
        if ((boolean)args[2].valor()) etq += 1;

        return etq;
    }
} 
class EtqExpnivel2 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList<String> x= (ArrayList<String>)args[0].valor();
        String op = x.get(0);
        int etq = (int)args[1].valor();
        if (!op.equals("and")) etq++;

        if ((boolean)args[2].valor()) etq += 1;
        if ((boolean)args[3].valor()) etq += 1;

        return etq;
    }
} 

class CodExpnivel1 implements SemFun{
   @Override
   public Object eval(Atributo... args) {

       ArrayList<String> cod = semantica.Semantica.creaCod(); 
       String op = ((ArrayList<String>)args[5].valor()).get(0);

       if (op.equals("or")){
           cod.addAll((ArrayList<String>)args[0].valor());
           if ((boolean)args[3].valor()) cod.add("apila_ind");
           cod.add("copia");
           cod.add("ir_v("+(int)args[1].valor()+")");
           cod.add("desapila");
           cod.addAll((ArrayList<String>)args[2].valor());
           if ((boolean)args[4].valor()) cod.add("apila_ind");
       } else {
           cod.addAll((ArrayList<String>)args[0].valor());
           if ((boolean)args[3].valor()) cod.add("apila_ind");
           cod.addAll((ArrayList<String>)args[2].valor());
           if ((boolean)args[4].valor()) cod.add("apila_ind");
           if (op.equals("suma") || op.equals("resta")) cod.add(op + "(" + ((Tipo)args[6].valor()).getTipo() + ")");
           else cod.add(op); 
       }
    return cod;
    }
} 

class CodExpnivel2 implements SemFun{
   @Override
   public Object eval(Atributo... args) {

       ArrayList<String>cod = semantica.Semantica.creaCod();
       String op = ((ArrayList<String>)args[0].valor()).get(0);
       if (op.equals("and"))          {
           cod.addAll((ArrayList<String>)args[1].valor());
           if ((boolean)args[4].valor()) cod.add("apila_ind");
           cod.add("copia");
           cod.add("ir_f("+(int)args[2].valor()+")");
           cod.add("desapila");
           cod.addAll((ArrayList<String>)args[3].valor());
           if ((boolean)args[5].valor()) cod.add("apila_ind");
       } else {
           cod.addAll((ArrayList<String>)args[1].valor());
           if ((boolean)args[4].valor()) cod.add("apila_ind");
           cod.addAll((ArrayList<String>)args[3].valor());
           if ((boolean)args[5].valor()) cod.add("apila_ind");
           
           if (op.equals("multiplica") || op.equals("divide"))  cod.add(op + "(" + ((Tipo)args[6].valor()).getTipo() + ")");
           else cod.add(op);
       }           
       return cod;
    }
} 



class EtqDesignadorIndex implements SemFun{

    @Override
    public Object eval(Atributo... args) {
        int etq = (int)args[0].valor() + 3;
        boolean esDesigExp = (boolean)args[1].valor();
        
        if (esDesigExp) etq += 1;
        
        return etq;
    }
}


class TipoDesignadorIndex implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        Tipo desigTipo = (Tipo) args[0].valor();
        Tipo tamTipo = (Tipo) args[1].valor();
        TablaDeSimbolos ts = (TablaDeSimbolos) args[2].valor();

        if (desigTipo.getTipo().equals("errorTipo") || tamTipo.getTipo().equals("errorTipo")) 
            return new TipoError();
        
        while (desigTipo.getTipo().equals("ref"))
            desigTipo = ts.getTipo(((TipoIdentificador)desigTipo).getId());
        
        /*while (tamTipo.getTipo().equals("ref"))
            tamTipo = ts.getTipo(((TipoIdentificador)tamTipo).getId());*/

        /*if (desigTipo.getTipo().equals("ref") && tamTipo.getTipo().equals("natural")){
             return ts.getTipo(((TipoIdentificador)desigTipo).getId());
        } */
           
        if (desigTipo.getTipo().equals("array") && tamTipo.getTipo().equals("natural")) 
            return ((TipoArray)desigTipo).getTipoBase();
        return new TipoError();
    }
} 

class CodDesignadorIndex implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        ArrayList<String> cod = Semantica.creaCod();
        Tipo tipo = ((Tipo)args[2].valor());
        TablaDeSimbolos ts = (TablaDeSimbolos) args[3].valor();
        boolean esDesigExp = (boolean) args[4].valor();
        
        if (tipo.getTipo().equals("errorTipo")) return cod;
        
        cod.addAll((ArrayList<String>)args[0].valor()); //desig1.cod
        cod.addAll((ArrayList<String>)args[1].valor()); //exp.cod
        
        if (esDesigExp) cod.add("apila_ind");

        while(tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());

        int tamTipoBase = (((TipoArray)tipo).getTipoBase()).getTam();
        cod.add("apila(" + tamTipoBase + ")");
        
        cod.add("multiplica");
        cod.add("suma");
                
        return cod;
    }
} 


class TipoDesignadorTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        Tipo tipo =  (Tipo) args[0].valor();
        int pos = Integer.parseInt((String)args[1].valor());
        TablaDeSimbolos ts = (TablaDeSimbolos) args[2].valor();
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        /*if (tipo.getTipo().equals("ref"))
            return ts.getTipo(((TipoIdentificador)tipo).getId());  */
        if (tipo.getTipo().equals("tupla"))
            return ((TipoTupla) tipo).getTipoTuplaPos(pos);
        else return new TipoError();
    }
} 

class CodDesignadorTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        ArrayList<String> cod = Semantica.creaCod();
        Tipo tipo =  (Tipo) args[1].valor();
        int pos = Integer.parseInt((String)args[2].valor());        
        TablaDeSimbolos ts = (TablaDeSimbolos) args[3].valor();
        
        if (tipo.getTipo().equals("errorTipo")) return cod;
         
        cod.addAll((ArrayList<String>)args[0].valor()); //desig1.cod
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        int desp = 0;
        if (tipo.getTipo().equals("tupla"))
            desp = ((TipoTupla)tipo).getDespTuplaPos(pos);
        cod.add("apila(" + desp + ")");
        cod.add("suma");

        return cod;
    }
}

class ConcatenaErroresDesignadorTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {

        ArrayList<Boolean> errores = Semantica.copiaErrores((ArrayList<Boolean>) args[0].valor());
        Tipo tipo = (Tipo) args[1].valor();
        TablaDeSimbolos ts = (TablaDeSimbolos) args[3].valor();
        int pos = Integer.parseInt((String)args[2].valor());

        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        boolean accesoTupla = false;
        if (tipo.getTipo().equals("tupla"))
            accesoTupla = !((TipoTupla)tipo).existeCampo(pos);
        
        errores.set(6, errores.get(6) | accesoTupla);
        return errores;
    }
}

// creo qe va while ref
class CodInstOut implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           ArrayList<String> cod = Semantica.copiaCod((ArrayList<String>) args[0].valor());
           boolean esDesig = (boolean) args[1].valor();
           Tipo tipo = (Tipo) args[2].valor();
           TablaDeSimbolos ts = (TablaDeSimbolos) args[3].valor();
  
           while (tipo.getTipo().equals("ref"))
                tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
           
           if (esDesig) cod.add("apila_ind");
           cod.add("write(" + tipo.getTipo() + ")");
           
           return cod;  
       }
}

class SumaEtqOut implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           int etq = (int) args[0].valor() + 1;
           boolean esDesig = (boolean) args[1].valor();
           if (esDesig) etq += 1;
           
           return etq;  
       }
}

class SumaEtqDesignadorMas1 implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           int etq = (int) args[0].valor() + 1;
           boolean esDesig = (boolean) args[1].valor();
           if (esDesig) etq += 1;
           
           return etq;  
       }
}

class SumaEtqDesignadorMas1DesigExp implements SemFun{
       @Override
       public Object eval(Atributo... args) {
       
           int etq = (int) args[0].valor() + 1;
           boolean esDesig = (boolean) args[1].valor();
           Tipo tipo = (Tipo) args[2].valor();
           if (tipo.getTam() == 1 && esDesig) 
               etq += 1;
           
           return etq;  
       }
}

class SumaEtqDesignador implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           int etq = (int) args[0].valor();
           boolean esDesig = (boolean) args[1].valor();
           if (esDesig) etq += 1;
           
           return etq;  
       }
}

class CodInstIf implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           ArrayList<String> cod = Semantica.creaCod();
           ArrayList<String> codExp = Semantica.copiaCod((ArrayList<String>) args[0].valor()); //exp.cod
           int etq = (int) args[1].valor();
           ArrayList<String> codInsts = Semantica.copiaCod((ArrayList<String>) args[2].valor()); //insts.cod
           boolean esDesig = (boolean) args[3].valor();
           
           cod.addAll(codExp);
           if (esDesig) cod.add("apila_ind");
           cod.add("ir_f(" + etq + ")");
           cod.addAll(codInsts);
           
           return cod; 
       }
}

class TiposCompatibles implements SemFun{
       @Override
       public Object eval(Atributo... args) {
          Tipo tipo1 =(Tipo)args[0].valor();
          Tipo tipo2 =(Tipo)args[1].valor();
          TablaDeSimbolos ts = (TablaDeSimbolos)args[2].valor();
         
          if (Semantica.tiposCompatibles(tipo1, tipo2, ts)) return tipo1;
          else return new TipoError();
       }
}

class ErrDesignadorInst implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
       boolean asignConstante = (((TablaDeSimbolos)args[0].valor()).esConst((String) args[1].valor()));
       ArrayList<Boolean> erroresDesig= (ArrayList<Boolean>) args[2].valor();
       ArrayList<Boolean> erroresExp= (ArrayList<Boolean>) args[3].valor();
               
       ArrayList<Boolean> errores = Semantica.unirErrores(erroresDesig, erroresExp );

       errores.set(4, errores.get(4) | asignConstante);
     
       return errores;
    }
}

class CodDesignadorInst implements SemFun{
   @Override
   public Object eval(Atributo... args) {

       ArrayList<String> cod = semantica.Semantica.creaCod(); 
       Tipo tipo = (Tipo)args[3].valor();
      
       cod.addAll((ArrayList<String>)args[0].valor());
       cod.addAll((ArrayList<String>)args[1].valor());
       boolean esDesig = (boolean)args[2].valor();
       if (tipo.getTam() > 1)  {
           cod.add("mueve(" + tipo.getTam() + ")");
       } 
       else { 
            if (esDesig) cod.add("apila_ind");
            cod.add("desapila_ind");
       }
       
       return cod;
    }
} 

class CodInstIfElse implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           ArrayList<String> cod = Semantica.creaCod();
           ArrayList<String> codExp = Semantica.copiaCod((ArrayList<String>) args[0].valor()); //exp.cod
           int etqInsts0 = (int) args[1].valor();          
           ArrayList<String> codInsts0 = Semantica.copiaCod((ArrayList<String>) args[2].valor()); //inst0.cod
           int etqInsts1 = (int) args[3].valor();     
           ArrayList<String> codInsts1 = Semantica.copiaCod((ArrayList<String>) args[4].valor()); //inst1.cod
           boolean esDesig = (boolean) args[5].valor();
           
           cod.addAll(codExp);
           if (esDesig) cod.add("apila_ind");
           cod.add("ir_f(" + (etqInsts0 + 1) + ")");
           cod.addAll(codInsts0);
           cod.add("ir_a(" + etqInsts1 + ")");
           cod.addAll(codInsts1);
           
           return cod; 
       }
}

class CodInstWhile implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           ArrayList<String> cod = Semantica.creaCod();
           ArrayList<String> codExp = Semantica.copiaCod((ArrayList<String>) args[0].valor()); //exp.cod
           int etqInsts = (int) args[1].valor();          
           ArrayList<String> codInsts = Semantica.copiaCod((ArrayList<String>) args[2].valor()); //inst0.cod
           int etqhInst = (int) args[3].valor(); 
           boolean esDesig = (boolean) args[4].valor();
           
           cod.addAll(codExp);
           if (esDesig) cod.add("apila_ind");
           cod.add("ir_f(" + (etqInsts + 1) + ")");
           cod.addAll(codInsts);
           cod.add("ir_a(" + etqhInst + ")");
           
           return cod; 
       }
}

class AsignacionTrueBool implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           return true;
         
       }
}
class AsignacionFalseBool implements SemFun{
       @Override
       public Object eval(Atributo... args) {
           
           return false;
         
       }
}

class AnadirTSYBorraLocal implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        TablaDeSimbolos ts = Semantica.eliminarTablaLocal((TablaDeSimbolos)args[0].valor());
        return  Semantica.creaTS(ts, (String)args[2].valor(), (String)args[3].valor(), 
                 (ArrayList<Boolean>)args[1].valor(), (Tipo)args[4].valor(),(int)args[5].valor());
    }
}

class CreaTSLocal implements SemFun{
    @Override
    public Object eval(Atributo... args) {
          TablaDeSimbolos ts=(TablaDeSimbolos)args[0].valor();
          
        return  Semantica.creaTablaLocal(Semantica.eliminarTablaLocal(ts));
    }
}

// mirar xq igual hay q mirar en ambas FIXME
class UnirErroresDecSubprogram implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[2].valor();
        boolean duplicado = ((TablaDeSimbolos)args[3].valor()).existeIdGlobal(id);
                
        ArrayList<Boolean> errores = Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor());
        return  Semantica.unirErrores(errores, duplicado , 0);
    }
}

class UnirMostrarErroresDecSubprogram implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        String id = (String)args[2].valor();
        boolean duplicado = ((TablaDeSimbolos)args[3].valor()).existeIdGlobal(id);
        String filaCol = (String)args[4].valor();
        String errores = (String) args[0].valor() + (String) args[1].valor();
        
        if (duplicado)
            errores += filaCol + "Error: Identificador '" + id + "' duplicado \n";                
        
        return errores;
    }
}

class CrearProc implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList <ContenidoProc> lista = (ArrayList <ContenidoProc>)args[0].valor();
        String id = (String) args[1].valor();
        Tipo tipoParam = (Tipo)args[2].valor();
        Tipo tipoCuerpoSub = (Tipo)args[3].valor();
  
        return Semantica.creaProc(lista, id, tipoParam, tipoCuerpoSub);
    }
}

class CopiaLista implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        ArrayList <ContenidoProc> lista = new ArrayList<ContenidoProc>();
        lista.addAll((ArrayList <ContenidoProc>)args[0].valor());
        
        return lista;
    }
}

class CrearListaVacia implements SemFun{
    @Override
    public Object eval(Atributo... args) {
 
        return new ArrayList<ContenidoProc>();
    }
}

class ClasePVar implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "pvar";
     }
}

class ModoValor implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "valor";
     }
}

class ModoVar implements SemFun{
    @Override
    public Object eval(Atributo... args) {  
        return "var";
     }
}

class UnirErroresParametrosFSub implements SemFun{
    @Override  
    public Object eval(Atributo... args) {
        String id = (String)args[3].valor();
        boolean duplicado = ((TablaDeSimbolos)args[2].valor()).existeIdSoloLocal(id);
        
        ArrayList<Boolean> errores = Semantica.unirErrores((ArrayList<Boolean>) args[0].valor(), (ArrayList<Boolean>) args[1].valor());
        return  Semantica.unirErrores(errores, duplicado , 0);
    }
}

class UnirMostrarErroresParametrosFSub implements SemFun{
    @Override  
    public Object eval(Atributo... args) {
        String id = (String)args[3].valor();
        boolean duplicado = ((TablaDeSimbolos)args[2].valor()).existeIdSoloLocal(id);
        String filaCol = (String)args[3].valor();
        String errores = (String) args[0].valor() + (String) args[1].valor();
        
        if (duplicado)
            errores += filaCol + " Error: Identificador  '" + id + "' duplicado \n";
        
        
        return  errores;
    }
}

class AnadirCampoProc implements SemFun{
    @Override   
    public Object eval(Atributo... args) {
        ArrayList<ContenidoProc> lista = (ArrayList<ContenidoProc>)args[0].valor();
        String id = (String)args[1].valor();
        String modo = (String)args[2].valor();
        Tipo tipo = (Tipo)args[3].valor();
        int desp = (int)args[4].valor();
        int dir = (int)args[5].valor();
        
        ContenidoProc elem = new ContenidoProc(id, modo, tipo, desp);
        
        
        lista.add(elem);
        
        return lista;
    }
}
class AnadirCampoProcCreaLista implements SemFun{ 
    @Override      
    public Object eval(Atributo... args) {
        ArrayList<ContenidoProc> lista = new ArrayList<ContenidoProc>();
        String id = (String)args[0].valor();
        String modo = (String)args[1].valor();
        Tipo tipo = (Tipo)args[2].valor();
        //int dir = (int)args[3].valor();
        
        ContenidoProc elem = new ContenidoProc(id, modo, tipo, 0);
        
        
        lista.add(elem);
        
        return lista;
    }
}

class AnadirTSDir0 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return  Semantica.creaTS((TablaDeSimbolos)args[0].valor(), (String)args[2].valor(), (String)args[3].valor(), 
                 (ArrayList<Boolean>)args[1].valor(), (Tipo)args[4].valor(),0);
    }
}


class SumaDespConTamTipoProc implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        int desp = (int)args[0].valor();
        Tipo tipo = ((Tipo)args[1].valor());
        String modo = ((String)args[2].valor());
        if (modo.equals("var")) return desp + 1;
        else return desp + tipo.getTam();
    }
}     

class SumaPrimerDespConTamTipoProc implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        Tipo tipo = ((Tipo)args[0].valor());
        String modo = ((String)args[1].valor());
        if (modo.equals("var")) return 1;
        else return tipo.getTam();
    }
}    


class CodigoCuerpoSub implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        // dependencias(inst.a("cod"),inst.a("etq"), paramf.a("cod"), identificador, paramf.a("cod"),inst.a("tsh"));
       
        ArrayList<String> cod = Semantica.creaCod();
        //ArrayList<String> codV = (ArrayList<String>) args[0].valor();
        ArrayList<String> codI = (ArrayList<String>) args[0].valor(); //1
        int tamVariables = (int)args[1].valor();  //2
        
        //cod.addAll(codV); 
        cod.addAll(Semantica.generaPrologo(tamVariables));        
        cod.addAll(codI);
        cod.addAll(Semantica.generaEpilogo(tamVariables));    
        cod.add("ir_ind");
        
        return cod;
    }
}

class ParamsHeredado implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        // dependencias(paramf.a("paramsh"),inst.a("tsh"),identificador);
        TablaDeSimbolos ts =(TablaDeSimbolos)args[0].valor();
        Tipo ti =ts.getTipo((String)args[1].valor());
        if (!ti.getTipo().equals("errorTipo"))
            return ((TipoProc)ti).getCampos();
        else return new ArrayList<ContenidoProc>();
        
    }
    
}  

class CopiaErroresCall implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       //dependencias(inst.a("err"),paramf.a("err"),inst.a("tsh"),identificador,numero);
       boolean noexisteId = !((TablaDeSimbolos)args[1].valor()).existeId((String)args[2].valor());
       boolean parametrosErroneo =false;
       int numeroParametros =(int)args[3].valor();
       Tipo ti = (Tipo) args[4].valor();
      
       if(!((String)ti.getTipo()).equals("errorTipo"))
       { int parametrosProc =((TipoProc)((TablaDeSimbolos)args[1].valor()).getTipo((String)args[2].valor())).getCampos().size();
         parametrosErroneo = numeroParametros!=parametrosProc;
       }
        
       ArrayList<Boolean> errores = (ArrayList<Boolean>) args[0].valor();
      
       errores.set(1, errores.get(1) | noexisteId);
       errores.set(7, errores.get(7) | parametrosErroneo);
       
       return errores;
    }
}      

class CodCall implements SemFun{
    @Override
    public Object eval(Atributo... args) {
     
       ArrayList<String> codigo = new ArrayList<String>();
       int dir=(int)args[0].valor();
       codigo.addAll(Semantica.cod_dirRetorno(dir));
       int dirSub= ((TablaDeSimbolos)args[3].valor()).getDir((String)args[2].valor());
       
       codigo.addAll((ArrayList<String>)args[1].valor());
       codigo.add("ir_a("+ dirSub +")");
       return codigo;
    } 
}    


class CodigoParametrosFCall0 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        ArrayList<String> cod = Semantica.creaCod();
        ArrayList<String> codParametrosFunC = (ArrayList<String>) args[0].valor(); 
        
        cod.add("apila_dir(0)");
        cod.add("apila(3)");
        cod.add("suma");
        
        cod.addAll(codParametrosFunC);    
        cod.add("desapila");
        
        return cod;
    }
    
}    

 
//Para el id=expr    
class ErrCall implements SemFun{
    @Override
    //dependencias(paramfuncall.a("err"),exp.a("err"),paramfuncall.a("tsh"),identificador,parahsm,);
    public Object eval(Atributo... args) {
       //dependencias(inst.a("err"),paramf.a("err"),inst.a("tsh"),identificador);
       boolean noexisteId = false;
       
        ArrayList<ContenidoProc> cont = (ArrayList<ContenidoProc>)args[3].valor();
       String id= (String)args[2].valor();
        Iterator<ContenidoProc> it = cont.iterator();
        while(it.hasNext() && !noexisteId){
            ContenidoProc c = it.next();
            if (id.equals(c.getId())) noexisteId=true;
        }
        
       
       ArrayList<Boolean> errores = (ArrayList<Boolean>) args[0].valor();
       errores.set(1, errores.get(1) | !noexisteId);
       return errores;
    }
}      

class CodCallId implements SemFun{
    @Override
    public Object eval(Atributo... args) {
     // dependencias(paramfuncall.a("cod"),exp.a("cod"),exp.a("esDesig"),paramfuncall.a("paramsh"),identificador);
      
       ArrayList<String> codigo = new ArrayList<String>();
       codigo.add("copia");
       
       //apila tañaño y suma
       String id = (String)args[3].valor();
       ArrayList<ContenidoProc> contenido = (ArrayList<ContenidoProc>)args[2].valor();
       String modo= "";
       int desp=0;
       int tam=0;
        Iterator<ContenidoProc> it = contenido.iterator();
        while(it.hasNext()){
            ContenidoProc c = it.next();
            if (id.equals(c.getId())) 
            { modo= c.getModo();
              desp=c.getDesp();
              tam=c.getTipo().getTam();
            }
        }
       //desplazamiento del parametro y se lo suma a la dir de comienzo 

       codigo.add("apila(" + desp + ")");

       codigo.add("suma");
       
       ArrayList<String> exp = (ArrayList<String>)args[0].valor();
       codigo.addAll(exp);       // va aqui creo
        
       boolean  esDesig = (boolean)args[1].valor();
       if (!esDesig )
       {
         if (modo.equals("valor"))
         {codigo.add("desapila_ind");}//
         else if (modo.equals("var"))
         {}//no se pone
       }
       else 
       {
          if (modo.equals("valor"))
           { codigo.add("mueve(" + tam+")");}
         else if (modo.equals("var"))
         { codigo.add("desapila_ind");}//
       }
       
           
      
     
      
       return codigo;
    } 
}    


        
class EtqCall implements SemFun{
    @Override
    // dependencias(paramfuncall.a("etq"),exp.a("etq"),paramfuncall.a("cod"));
    public Object eval(Atributo... args) {

      //dependencias(paramfuncall.a("etq"),exp.a("etq"),exp.a("esDesig"),paramfuncall.a("paramsh"));
     
      int etq=(int)args[0].valor();
     return etq+3;
    }
}    

class TipoCompatibleCall implements SemFun{
    @Override
    public Object eval(Atributo... args) {
               //dependencias(paramfuncall.a("tipo"),exp.a("tipo"),paramfuncall.a("paramsh"),identificador);
       TablaDeSimbolos ts = (TablaDeSimbolos) args[3].valor();
       Tipo ti= (Tipo)args[0].valor();
       ArrayList<ContenidoProc> contenido = (ArrayList<ContenidoProc>)args[1].valor();
       String id = (String)args[2].valor();
       
       Tipo param = new TipoError();
       Iterator<ContenidoProc> it = contenido.iterator();
        while(it.hasNext() && param.getTipo().equals("errorTipo")){
            ContenidoProc c = it.next();
            if (id.equals(c.getId())) param=c.getTipo();
        }
        
       if (param.getTipo().equals("errorTipo")) return new TipoError();
       
       if (Semantica.tiposCompatibles(param, ti, ts))
           return param;
       else return new TipoError();
               
    }
}   

class UnirMostrarTresErrores implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        return (String)args[0].valor() + (String)args[1].valor() + (String)args[2].valor();
               
    }
}   

class MostrarErroresInstsIn implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        String errores = (String) args[0].valor();
        String id = (String) args[1].valor();
        TablaDeSimbolos ts =(TablaDeSimbolos)args[2].valor();
        Tipo tipo = (Tipo) args[3].valor(); //desig.tipo
        String filaCol = (String) args[4].valor(); //desig.tipo
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
        boolean asignacionConstante = ts.esConst(id); //Error 4
        boolean noTipoBasicoIn = !Semantica.esTipoBasico(tipo); //Error5

        if (asignacionConstante) 
             errores += filaCol + " Error: Asignacion a constante '" + id + "'\n";        
        if (noTipoBasicoIn)
             errores += filaCol + " Error: Tipo de '" + id + "' no es tipo basico. Es de tipo " + tipo.getTipo() + " \n";

        return errores;
               
    }
}    

class MostrarErroresInstsOut implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
        String errores = (String) args[0].valor();
        Tipo tipo = (Tipo) args[1].valor(); //desig.tipo
        String filaCol = (String) args[2].valor(); //desig.tipo   
        TablaDeSimbolos ts =(TablaDeSimbolos)args[3].valor();
        
        while (tipo.getTipo().equals("ref"))
            tipo = ts.getTipo(((TipoIdentificador)tipo).getId());
        
         boolean noTipoBasicoIn = !Semantica.esTipoBasico(tipo); //Error5
      
        if (noTipoBasicoIn)
             errores += filaCol + " Error: La expresion del 'out' no es un tipo basico. Es de tipo " + tipo.getTipo() + " \n";

        return errores;
    }
}  

class MostrarErroresDesignadorInst implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
       String errores = (String) args[2].valor() + (String) args[3].valor();
       String id = (String) args[1].valor();
       TablaDeSimbolos ts =(TablaDeSimbolos)args[0].valor();
       Tipo tipoDesig = (Tipo) args[4].valor(); //desig.tipo
       Tipo tipoExp = (Tipo) args[5].valor(); //exp.tipo
       String filaCol = (String) args[6].valor();
       boolean asignacionConstante = ts.esConst(id);
      
       if (asignacionConstante) 
             errores += filaCol + " Error: Asignacion a constante '" + id + "'\n";
       if (!Semantica.tiposCompatibles(tipoDesig, tipoExp, ts)){
           tipoDesig = Semantica.tipoRec(tipoDesig, ts);
           tipoExp = Semantica.tipoRec(tipoExp, ts);
           errores += filaCol + " Error: Los tipos '" + tipoDesig.getTipo() + "' y '" + tipoExp.getTipo() + "' no son compatibles \n";
       } 
            
       return errores;
    }
}

class MostrarErroresInstCall implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       
       String errores = (String) args[0].valor();
       String id = (String) args[2].valor();
       TablaDeSimbolos ts =(TablaDeSimbolos)args[1].valor();
       int numeroParametros =(int)args[3].valor();
       String filaCol = (String) args[4].valor();
       boolean noexisteId = !ts.existeId(id);
       boolean parametrosErroneo=false;
       Tipo ti = (Tipo) args[5].valor();
       
       if(!((String)ti.getTipo()).equals("errorTipo")) {     
            int parametrosProc =((TipoProc)ts.getTipo(id)).getCampos().size();
            parametrosErroneo = numeroParametros!=parametrosProc;
       }
       if (noexisteId)
             errores += filaCol + " Error: No existe el id '" + id + "'\n";
       if (parametrosErroneo)
             errores += filaCol + " Numero de parametros erroneo en el call \n";
       return errores;
    }
}      
  
class MostrarErroresCall implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       String errores = (String) args[0].valor();
       String id = (String) args[1].valor();
       ArrayList<ContenidoProc> cont = (ArrayList<ContenidoProc>)args[2].valor();
       Tipo tipoExp = (Tipo) args[3].valor();
       String filaCol =(String)args[4].valor();
       TablaDeSimbolos ts= (TablaDeSimbolos) args[5].valor();
       boolean existeId = false;
       
       Iterator<ContenidoProc> it = cont.iterator();
        while(it.hasNext() && !existeId){
            ContenidoProc c = it.next();
            existeId = id.equals(c.getId());
        }
   
       Tipo param = new TipoError();
       it = cont.iterator();
        while(it.hasNext() && param.getTipo().equals("errorTipo")){
            ContenidoProc c = it.next();
            if (id.equals(c.getId())) param=c.getTipo();
        }
        
       if (!existeId) 
             errores += filaCol + " Error: No existe el id '" + id + "' en el 'call'\n";
       else {
           if (!Semantica.tiposCompatibles(param, tipoExp, ts)){
                param = Semantica.tipoRec(param, ts);
                tipoExp = Semantica.tipoRec(tipoExp, ts);
                errores += filaCol + " Error: Los tipos '" + param.getTipo() + "' y '" + tipoExp.getTipo() + "' no son compatibles \n";
           }
       }
       
       return errores;
    }
}      


class MostrarErroresExp implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       String errores = (String) args[0].valor() + (String) args[1].valor();
       ArrayList<String> op = (ArrayList<String>) args[2].valor();
       Tipo tipoI = (Tipo) args[3].valor();
       Tipo tipoD = (Tipo) args[4].valor();
       String filaCol =(String)args[5].valor();
       TablaDeSimbolos ts = (TablaDeSimbolos)args[6].valor();
       
       Tipo tipoResultante = Semantica.consultarTipoResultante(tipoI.getTipo() + tipoD.getTipo() + op.get(0));

       if (tipoResultante.getTipo().equals("errorTipo")) {
           tipoI = Semantica.tipoRec(tipoI, ts);
           tipoD = Semantica.tipoRec(tipoD, ts);
           errores += filaCol + " Error: El operador '" + op.get(0) + "' no puede aplicarse entre los tipos '" + tipoI.getTipo() + "' y '" + tipoD.getTipo() + "'\n";   
       }
       return errores;
    }
}    

class MostrarErroresExpNivel4 implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       String errores = (String) args[0].valor();
       ArrayList<String> op = (ArrayList<String>) args[1].valor();
       Tipo tipo = (Tipo) args[2].valor();       
       String filaCol =(String)args[3].valor();
       TablaDeSimbolos ts = (TablaDeSimbolos)args[4].valor();
       
       Semantica.consultarTipoResultante(tipo.getTipo() + op.get(0)); 
       
       if (Semantica.consultarTipoResultante(tipo.getTipo() + op.get(0)).equals("errorTipo")){
           tipo = Semantica.tipoRec(tipo, ts);
           errores += filaCol + " Error: El operador '" + op.get(0) + "' no puede aplicarse al tipo '" + tipo.getTipo() + "'\n";
       }    
       return errores;
    }    
}     

class MostrarErroresDesigIden implements SemFun{
    @Override
    public Object eval(Atributo... args) {

       String id = (String) args[0].valor();     
       TablaDeSimbolos ts = (TablaDeSimbolos)args[1].valor();
       String filaCol =(String)args[2].valor();
       String errores = "";
       boolean noExisteId = !ts.existeId(id);
       
       if (noExisteId) 
             errores += filaCol + " Error: No existe el id '" + id + "'\n";
       
       return errores;
    }    
}  

class MostrarErroresDesignadorArray implements SemFun{
    @Override
    public Object eval(Atributo... args) {
       String errores = (String) args[0].valor() + (String) args[1].valor(); 
       Tipo desigTipo = (Tipo) args[2].valor();
       Tipo tamTipo = (Tipo) args[3].valor();
       TablaDeSimbolos ts = (TablaDeSimbolos)args[4].valor();
       String id =(String)args[5].valor();
       String filaCol =(String)args[6].valor();
       
       while (desigTipo.getTipo().equals("ref"))
            desigTipo = ts.getTipo(((TipoIdentificador)desigTipo).getId());
        
        if (!desigTipo.getTipo().equals("array"))
            errores += filaCol + " Error: Tipo del designador no es array '" + id + ". Es de tipo " + desigTipo.getTipo() + " '\n";
            
        if (!tamTipo.getTipo().equals("natural")) 
            errores += filaCol + " Error: Para acceder a un array es necesario que sea natural '" + id + "'\n";             
       
       return errores;
    }    
}  

class MostrarErroresDesignadorTupla implements SemFun{
    @Override
    public Object eval(Atributo... args) {
        
       String errores = (String) args[0].valor(); 
       int pos = Integer.parseInt((String)args[1].valor());
       Tipo tipo = (Tipo) args[2].valor();       
       String id =(String)args[3].valor();
       String filaCol =(String)args[4].valor();
        
        if (tipo.getTipo().equals("errorTipo"))
            errores += filaCol + " Error: No existe el campo '" + pos + "' de la tupla del designador '" + id + "'\n";
    
       
       return errores;
    }    
}  


public class EAtribucion extends Atribucion {
    
    // Se crean los objetos que representan las diferentes funciones semánticas
                        private static SemFun asignacionP = new AsignacionP();
    private static SemFun asignacion3 = new Asignacion3();
    private static SemFun asignacion2 = new Asignacion2();
    private static SemFun asignacion0 = new Asignacion0();
    private static SemFun asignacion1 = new Asignacion1();
    private static SemFun asignacionmenos = new AsignacionMenos();
    private static SemFun asignacion = new Asignacion();
    private static SemFun asignacionTrue = new AsignacionTrue();
    private static SemFun asignacionFalse = new AsignacionFalse();
    private static SemFun creaNatural = new CreaNatural();
    private static SemFun creaInt = new CreaInt();
    private static SemFun creaChar = new CreaChar();
    private static SemFun creaBool = new CreaBool();
    private static SemFun creaFloat =  new CreaFloat();
    private static SemFun claseConst = new ClaseConst();
    private static SemFun codVacio = new CodVacio();
    private static SemFun codMostrarErroresVacio = new CodMostrarErroresVacio();
    private static SemFun creaErrores = new CreaErrores();
    private static SemFun creaTs = new CreaTs();
    private static SemFun asignacionSuma1 = new AsignacionSuma1();
    private static SemFun asignacionSuma2 = new AsignacionSuma2();
    private static SemFun asignacionSuma3 = new AsignacionSuma3();
    private static SemFun asignacionSuma13 = new AsignacionSuma13();
    private static SemFun asignacionSuma14 = new AsignacionSuma14();
    private static SemFun asignacionSuma5 = new AsignacionSuma5();
    private static SemFun errorTipoMostrarErrores = new ErrorTipoMostrarErrores();
    private static SemFun asignacionTipoConsante = new InicializacionTipoConstante();
    private static SemFun asignacionCodDecConst = new AsignacionCodDecConst();
    private static SemFun asignacionTSDecConsts = new AsignacionTSDecConsts();
    private static SemFun unirDosTipos = new UnirDosTipos();
    private static SemFun unirTresTipos = new UnirTresTipos();
    private static SemFun unirCincoTipos = new UnirCincoTipos();
    private static SemFun copiaErroresOrDuplicado = new CopiaErroresOrDuplicado();
    private static SemFun unirErroresOrDuplicado = new UnirErroresOrDuplicado();
    private static SemFun apilaInicializacionConstante = new AsignacionCodConstante();
    private static SemFun sumaDirConTam = new SumaDirConTam();
    private static SemFun anadirTS = new AnadirTS();
    private static SemFun anadirTSTipo = new AnadirTSTipo();
    private static SemFun copiaErrores = new CopiaErrores();
    private static SemFun creaTipo = new CreaTipo();
    private static SemFun copiaCodigo = new CopiaCodigo(); 
    private static SemFun claseVar = new ClaseVar();
    private static SemFun claseTipo = new ClaseTipo();
    private static SemFun claseSubprograma = new ClaseSubprograma();
    private static SemFun concatenaDosCod = new ConcatenaDosCod();
    private static SemFun concatena2CodYDesapila = new Concatena2CodYDesapila();
    private static SemFun creaCodMen = new CreaCodMen();
    private static SemFun creaCodMay = new CreaCodMay();
    private static SemFun creaCodMenIgual = new CreaCodMenIgual();
    private static SemFun creaCodMayIgual = new CreaCodMayIgual();
    private static SemFun creaCodIgual = new CreaCodIgual();
    private static SemFun creaCodNoIgual = new CreaCodNoIgual();
    private static SemFun creaCodMas = new CreaCodMas();
    private static SemFun creaCodMenos = new CreaCodMenos();
    private static SemFun creaCodOr = new CreaCodOr();
    private static SemFun creaCodMul = new CreaCodMul();
    private static SemFun creaCodDiv = new CreaCodDiv();
    private static SemFun creaCodMod = new CreaCodMod();
    private static SemFun creaCodAnd = new CreaCodAnd();
    private static SemFun creaCodDespDer = new CreaCodDespDer();
    private static SemFun creaCodDespIzq = new CreaCodDespIzq();
    private static SemFun creaCodMenosUnario = new CreaCodMenosUnario(); 
    private static SemFun creaCodNot = new CreaCodNot();
    private static SemFun creaCodCastChar = new CreaCodCastChar();
    private static SemFun creaCodCastNat = new CreaCodCastNat(); 
    private static SemFun creaCodCastInt = new CreaCodCastInt();
    private static SemFun creaCodCastFloat = new CreaCodCastFloat(); 
    private static SemFun unirDosErrores = new UnirDosErrores(); 
    private static SemFun unirTresErrores = new UnirTresErrores();
    private static SemFun unirCincoErrores = new UnirCincoErrores();
    private static SemFun unirMostrarCincoErrores = new UnirMostrarCincoErrores();
    private static SemFun concatenaCodProg = new ConcatenaCodProg();
    private static SemFun concatenaCodInsts = new ConcatenaCodInsts();
    private static SemFun tipoDeIdConTS = new TipoDeIdConTS();
    private static SemFun dameTipoDeIdConTS = new DameTipoDeIdConTS();
    private static SemFun creaErroresTipoIdentificador = new CreaErroresTipoIdentificador();
    private static SemFun creaArray = new CreaArray();
    private static SemFun creaArrayIdentificador = new CreaArrayIdentificador();
    private static SemFun creaErroresTipoArrayIdentificador = new CreaErroresTipoArrayIdentificador();
    private static SemFun dameTamTipo = new DameTamTipo();
    private static SemFun primerCampoTupla = new PrimerCampoTupla();
    private static SemFun sumaDespConTamTipo = new SumaDespConTamTipo();
    private static SemFun anadirCampoTupla = new AnadirCampoTupla();
    private static SemFun creaTuplaVacia = new CreaTuplaVacia();
    private static SemFun creaTupla = new CreaTupla();
    private static SemFun creaCodSwap1 = new CreaCodSwap1();
    private static SemFun creaCodSwap2 = new CreaCodSwap2();
    private static SemFun copiaErroresInstsIn = new CopiaErroresInstsIn();
    private static SemFun creaErroresDesigIden = new CreaErroresDesigIden();
    private static SemFun codDesigIden = new CodDesigIden();
    private static SemFun etqDesigIden = new EtqDesigIden();
    private static SemFun codInstIn = new CodInstIn();
    private static SemFun etqInstIn = new EtqInstIn();
    private static SemFun etqDesignadorIndex = new EtqDesignadorIndex();
    private static SemFun tipoDesignadorIndex = new TipoDesignadorIndex();
    private static SemFun codDesignadorIndex = new CodDesignadorIndex();
    private static SemFun tipoDesignadorTupla = new TipoDesignadorTupla();
    private static SemFun codDesignadorTupla = new CodDesignadorTupla();
    private static SemFun concatenaErroresDesignadorTupla = new ConcatenaErroresDesignadorTupla();
    private static SemFun tipoResultante2 = new TipoResultante2();
    private static SemFun codExp = new CodExp();
    private static SemFun sumaEtqExp = new SumaEtqExp();
    private static SemFun irf_irv_Op = new Irf_irv_OpOr();
    private static SemFun irf_irv_OpSuma2 = new Irf_irv_OpOrSuma2();
    private static SemFun irf_irv_OpAnd = new Irf_irv_OpAnd();
    private static SemFun irf_irv_OpAndSuma2 = new Irf_irv_OpAndSuma2();
    private static SemFun etqhSuma3 = new EtqhSuma3();
    private static SemFun etqExpnivel1 = new EtqExpnivel1();
    private static SemFun codExpnivel1 = new CodExpnivel1();
    private static SemFun etqExpnivel2 = new EtqExpnivel2();
    private static SemFun etqhSuma3Expnivel2 = new EtqhSuma3ExpNivel2();
    private static SemFun codExpnivel2 = new CodExpnivel2();
    private static SemFun tipoResultante1 =new TipoResultante1(); 
    private static SemFun codExpnivel4 = new CodExpNivel4();
    private static SemFun codApilaValor = new CodApilaValor();
    private static SemFun codApilaCharacter = new CodApilaCharacter();
    private static SemFun codApilafalse = new CodApilaFalse();
    private static SemFun codApilatrue = new CodApilaTrue();
    private static SemFun codInstOut = new CodInstOut();
    private static SemFun sumaEtqOut = new SumaEtqOut();
    private static SemFun sumaEtqDesignadorMas1 = new SumaEtqDesignadorMas1();
    private static SemFun sumaEtqDesignador = new SumaEtqDesignador();
    private static SemFun codInstIf = new CodInstIf();
    private static SemFun codInstIfElse = new CodInstIfElse();
    private static SemFun codInstWhile = new CodInstWhile();
    private static SemFun tiposCompatibles = new TiposCompatibles();
    private static SemFun errDesignadorInst = new ErrDesignadorInst();
    private static SemFun codDesignadorInst = new CodDesignadorInst();
    private static SemFun asignacionTrueBool = new AsignacionTrueBool();
    private static SemFun asignacionFalseBool = new AsignacionFalseBool();
    private static SemFun anadirTSYBorraLocal = new AnadirTSYBorraLocal();
    private static SemFun creaTSLocal = new CreaTSLocal();
    private static SemFun unirErroresDecSubprogram = new UnirErroresDecSubprogram();
    private static SemFun crearProc = new CrearProc();
    private static SemFun copiaLista = new CopiaLista();
    private static SemFun crearListaVacia = new CrearListaVacia();
    private static SemFun clasePVar = new ClasePVar();
    private static SemFun modoVar = new ModoVar();
    private static SemFun modoValor = new ModoValor();
    private static SemFun unirErroresParametrosFSub = new UnirErroresParametrosFSub(); 
    private static SemFun anadirCampoProc = new AnadirCampoProc();
    private static SemFun dirConTam = new DirConTam();
    private static SemFun anadirTSDir0 = new AnadirTSDir0();
    private static SemFun codigoCuerpoSub = new CodigoCuerpoSub();
    private static SemFun sumaDespConTamTipoProc = new SumaDespConTamTipoProc();
    private static SemFun sumaPrimerDespConTamTipoProc = new SumaPrimerDespConTamTipoProc();
    private static SemFun anadirCampoProcCreaLista = new AnadirCampoProcCreaLista();
    private static SemFun sumaEtqDesignadorMas1DesigExp = new SumaEtqDesignadorMas1DesigExp();
    private static SemFun codigoParametrosFCall0 = new CodigoParametrosFCall0(); 
    private static SemFun paramsHeredado = new ParamsHeredado();
    private static SemFun copiaErroresCall = new CopiaErroresCall();
    private static SemFun codCall = new CodCall();
    private static SemFun errCall = new ErrCall();
    private static SemFun codCallId = new CodCallId();
    private static SemFun etqCall = new EtqCall();
    private static SemFun tipoCompatibleCall = new TipoCompatibleCall();
    private static SemFun unirMostrarDosErrores = new UnirMostrarDosErrores();
    private static SemFun unirMostrarErroresOrDuplicado = new UnirMostrarErroresOrDuplicado();
    private static SemFun copiaMostrarErroresOrDuplicado = new CopiaMostrarErroresOrDuplicado();
    private static SemFun creaMostrarErroresTipoArrayIdentificador = new CreaMostrarErroresTipoArrayIdentificador();
    private static SemFun creaMostrarErroresTipoIdentificador = new CreaMostrarErroresTipoIdentificador();
    private static SemFun unirMostrarErroresDecSubprogram = new UnirMostrarErroresDecSubprogram();
    private static SemFun unirMostrarErroresParametrosFSub = new UnirMostrarErroresParametrosFSub();
    private static SemFun tipoInstOut = new TipoInstOut();
    private static SemFun tipoInstIn = new TipoInstIn();
    private static SemFun unirMostrarTresErrores = new UnirMostrarTresErrores();           
    private static SemFun mostrarErroresInstsIn = new MostrarErroresInstsIn();
    private static SemFun mostrarErroresInstsOut = new MostrarErroresInstsOut();
    private static SemFun mostrarErroresDesignadorInst = new MostrarErroresDesignadorInst();
    private static SemFun mostrarErroresInstCall = new MostrarErroresInstCall();
    private static SemFun mostrarErroresCall = new MostrarErroresCall();
    private static SemFun mostrarErroresExp = new MostrarErroresExp();
    private static SemFun mostrarErroresExpNivel1 = new MostrarErroresExp();    
    private static SemFun mostrarErroresExpNivel2 = new MostrarErroresExp();
    private static SemFun mostrarErroresExpNivel3 = new MostrarErroresExp();
    private static SemFun mostrarErroresExpNivel4 = new MostrarErroresExpNivel4();    
    private static SemFun mostrarErroresDesigIden = new MostrarErroresDesigIden();    
    private static SemFun mostrarErroresDesignadorArray = new MostrarErroresDesignadorArray();
    private static SemFun mostrarErroresDesignadorTupla = new MostrarErroresDesignadorTupla();  
   

    
TAtributos prog(Token iden,TAtributos constantes, TAtributos tipos,TAtributos variables, TAtributos subprogramas,TAtributos instrucciones){
       regla("PROG -> PROGRAM : identificador {Declaraciones Instrucciones}");
       
       TAtributos prog = atributosPara("PROG", "cod","ts","err","tipo","etq","dir","mostrarErrores");
       Atributo nombrePrograma = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
       
       dependencias(tipos.a("tsh"), constantes.a("ts"));
       dependencias(variables.a("tsh"), tipos.a("ts"));
       dependencias(variables.a("dirh"), constantes.a("dir"));
       dependencias(subprogramas.a("tsh"), variables.a("ts"));
       dependencias(subprogramas.a("etqh"), constantes.a("etq"));
       dependencias(instrucciones.a("tsh"),subprogramas.a("ts"));
       dependencias(instrucciones.a("etqh"),subprogramas.a("etq"));
       
       dependencias(prog.a("ts"),subprogramas.a("ts"));
       dependencias(prog.a("err"),constantes.a("err"),tipos.a("err"),variables.a("err"),subprogramas.a("err"),instrucciones.a("err"));
       dependencias(prog.a("tipo"), constantes.a("tipo"),tipos.a("tipo"),variables.a("tipo"),subprogramas.a("tipo"),instrucciones.a("tipo"));
       dependencias(prog.a("cod"), constantes.a("cod"),subprogramas.a("cod"),variables.a("dir"),subprogramas.a("etq"),instrucciones.a("cod"),prog.a("err"),prog.a("tipo"));
       dependencias(prog.a("etq"),instrucciones.a("etq"));
       dependencias(prog.a("dir"),subprogramas.a("dir"));
       dependencias(prog.a("mostrarErrores"),constantes.a("mostrarErrores"),tipos.a("mostrarErrores"),variables.a("mostrarErrores"),subprogramas.a("mostrarErrores"),instrucciones.a("mostrarErrores"));
       
       
       calculo(tipos.a("tsh"), asignacion);
       calculo(variables.a("dirh"), asignacion);
       calculo(variables.a("tsh"), asignacion);
       calculo(subprogramas.a("tsh"), asignacion);
       calculo(subprogramas.a("etqh"), asignacionSuma5);
       calculo(instrucciones.a("tsh"), asignacion);
       calculo(instrucciones.a("etqh"), asignacion);
       
       calculo(prog.a("ts"), asignacion);
       calculo(prog.a("err"), unirCincoErrores);
       calculo(prog.a("tipo"), unirCincoTipos);
       calculo(prog.a("cod"), concatenaCodProg);
       calculo(prog.a("etq"), asignacionSuma1);
       calculo(prog.a("dir"), asignacion);
       calculo(prog.a("mostrarErrores"), unirMostrarCincoErrores);
       
       return prog;
    } 
    
      public TAtributos constantes1(TAtributos decconsts ) {
        regla("Constantes →  consts { DecConsts }");
        
        TAtributos constante1 = atributosPara("CONSTANTES", "cod", "err","tipo","dir","etq","ts","mostrarErrores");
                
        dependencias(constante1.a("cod"),decconsts.a("cod"),constante1.a("err"),constante1.a("tipo"));
        dependencias(constante1.a("err"),decconsts.a("err"));
        dependencias(constante1.a("tipo"),decconsts.a("tipo"));
        dependencias(constante1.a("dir"),decconsts.a("dir"));
        dependencias(constante1.a("etq"),decconsts.a("etq"));
        dependencias(constante1.a("ts"),decconsts.a("ts"));
        dependencias(constante1.a("mostrarErrores"),decconsts.a("mostrarErrores"));
        
        calculo(constante1.a("ts"), asignacion);
        calculo(constante1.a("err"), copiaErrores);
        calculo(constante1.a("tipo"), asignacion);
        calculo(constante1.a("dir"), asignacion);
        calculo(constante1.a("cod"), copiaCodigo);
        calculo(constante1.a("etq"), asignacion);
        calculo(constante1.a("mostrarErrores"), asignacion);
        
        return constante1;
     } 
      
   public TAtributos constantes2(  ) {
        regla("Constantes →  λ");
        
        TAtributos constante2 = atributosPara("CONSTANTES", "cod","ts","err","tipo","etq","dir","mostrarErrores");
        
       calculo(constante2.a("ts"), creaTs);
       calculo(constante2.a("err"), creaErrores);
       calculo(constante2.a("tipo"), creaTipo);
       calculo(constante2.a("cod"), codVacio);
       calculo(constante2.a("etq"), asignacion0);
       calculo(constante2.a("dir"), asignacion2);
       calculo(constante2.a("mostrarErrores"), codMostrarErroresVacio);
       
       return constante2;
     } 
   
   
   
    public TAtributos decconsts0(TAtributos decconsts,TAtributos decconst) {
        regla("DecConsts →  DecConsts DecConst");
        
        TAtributos decconsts0 = atributosPara("DECCONSTS","cod","err","tipo","dir","ts","etq","mostrarErrores");
                    
       dependencias(decconsts0.a("err"),decconsts.a("err"),decconsts.a("ts"),decconst.a("id"));        
       dependencias(decconsts0.a("tipo"),decconsts.a("tipo"),decconst.a("tipo"));
       dependencias(decconsts0.a("dir"),decconsts.a("dir"));
       dependencias(decconsts0.a("ts"),decconsts.a("ts"),decconsts0.a("err"),decconst.a("id"),decconst.a("clase"),decconst.a("tipo"),decconsts.a("dir"));
       dependencias(decconsts0.a("cod"),decconsts.a("cod"),decconst.a("cod"),decconsts0.a("ts"),decconst.a("id"),decconsts.a("err"),decconst.a("tipo"));
       dependencias(decconsts0.a("etq"),decconsts.a("etq")); 
       dependencias(decconsts0.a("mostrarErrores"),decconsts.a("mostrarErrores"),decconsts.a("ts"),decconst.a("id"),decconst.a("filaCol"));        
       
       
       calculo(decconsts0.a("err"), copiaErroresOrDuplicado);
       calculo(decconsts0.a("tipo"),unirDosTipos );
       calculo(decconsts0.a("dir"), asignacionSuma1);
       calculo(decconsts0.a("ts"), anadirTS);
       calculo(decconsts0.a("cod"),concatena2CodYDesapila);
       calculo(decconsts0.a("etq"), asignacionSuma2);
       calculo(decconsts0.a("mostrarErrores"), copiaMostrarErroresOrDuplicado);
       
       return decconsts0;
     } 
     public TAtributos decconsts1(TAtributos decconst) {
        regla("DecConsts →  DecConst");
        
        TAtributos decconsts = atributosPara("DECCONSTS", "cod","err","tipo","dir","ts","etq","filaCol","mostrarErrores"); 
                
        dependencias(decconsts.a("tipo"),decconst.a("tipo"));
        dependencias(decconsts.a("ts"),decconst.a("id"),decconst.a("clase"),decconst.a("tipo"));
        dependencias(decconsts.a("cod"),decconst.a("cod"),decconsts.a("ts"),decconst.a("id"),decconsts.a("err"),decconst.a("tipo"));        
        dependencias(decconsts.a("filaCol"),decconst.a("filaCol"));
        dependencias(decconsts.a("mostrarErrores"),decconst.a("mostrarErrores"));
        
        calculo(decconsts.a("etq"), asignacion2);
        calculo(decconsts.a("err"), creaErrores);
        calculo(decconsts.a("tipo"), asignacion);
        calculo(decconsts.a("cod"), asignacionCodDecConst);
        calculo(decconsts.a("dir"), asignacion3);
        calculo(decconsts.a("ts"), asignacionTSDecConsts);
        calculo(decconsts.a("filaCol"), asignacion);
        calculo(decconsts.a("mostrarErrores"),asignacion);
        
        return decconsts;
     } 
    
       public TAtributos decconst(TAtributos tipobasico,Token iden,TAtributos valor) {
        regla("Consts -> const TipoBásico identificador := valor ");
        
        TAtributos decconst = atributosPara("DECCONST", "cod","tipo","clase","id","filaCol","mostrarErrores");
        Atributo id = atributoLexicoPara("STRING","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(decconst.a("tipo"),tipobasico.a("tipo"),valor.a("valor") );
        dependencias(decconst.a("id"),id );
        dependencias(decconst.a("cod"),tipobasico.a("tipo"),valor.a("valor") );
        dependencias(decconst.a("filaCol"),filaCol );
        dependencias(decconst.a("mostrarErrores"),filaCol,tipobasico.a("tipo"),valor.a("valor"),id);
       
        calculo(decconst.a("id"), asignacion);
        calculo(decconst.a("clase"), claseConst);
        calculo(decconst.a("tipo"), asignacionTipoConsante);
        calculo(decconst.a("cod"), apilaInicializacionConstante);
        calculo(decconst.a("filaCol"), asignacion);
        calculo(decconst.a("mostrarErrores"), errorTipoMostrarErrores);
        
        return decconst; 
     } 
       
       
 
   /*FUNCIONES CALCULAR VALOR */

     public TAtributos vchar(Token valor2) {
        regla("VALOR → vchar ");
        
        TAtributos vchar = atributosPara("VALOR", "valor");
        Atributo astring= atributoLexicoPara("STRING","lex",valor2.lex());
        dependencias(vchar.a("valor"),astring );
        
        calculo(vchar.a("valor"), asignacion);
        return vchar;
     }  

   public TAtributos vbooleanTrue() {
        regla("VALOR → true ");
        
        TAtributos vtrue = atributosPara("VALOR", "valor");
        
        calculo(vtrue.a("valor"), asignacionTrue);
        
        return vtrue;
     } 
     
        
    public TAtributos vbooleanFalse() {
        regla("VALOR → false ");
        
        TAtributos vfalse = atributosPara("VALOR", "valor");
        
        calculo(vfalse.a("valor"), asignacionFalse);
       
        return vfalse;
     }
    
    public TAtributos vnat(Token valor2) {
        regla("VALOR → false ");
        
        TAtributos vnat = atributosPara("VALOR", "valor");
        Atributo astring = atributoLexicoPara("STRING","lex",valor2.lex());
        dependencias(vnat.a("valor"),astring );
        
        calculo(vnat.a("valor"), asignacion);
        return vnat;
     }
    
    public TAtributos vfloat(Token valor2) {
        regla("VALOR → false ");
        
        TAtributos vfloat = atributosPara("VALOR", "valor");
        Atributo astring = atributoLexicoPara("STRING","lex",valor2.lex());
        dependencias(vfloat.a("valor"),astring );
        
        calculo(vfloat.a("valor"), asignacion);
        return vfloat;
     }


    public TAtributos vint(Token valor2) {
        regla("VALOR → MENOS VNATURAL ");
        
        TAtributos vint = atributosPara("VALOR", "valor");
        Atributo astring= atributoLexicoPara("STRING","lex",valor2.lex());
        dependencias(vint.a("valor"),astring );
        
        calculo(vint.a("valor"), asignacionmenos);
        return vint;
     }
    
    public TAtributos vmenosfloat(Token valor2) {
        regla("VALOR → MENOS VNATURAL ");
        
        TAtributos vmenosfloat = atributosPara("VALOR", "valor");
        Atributo astring= atributoLexicoPara("STRING","lex",valor2.lex());
        dependencias(vmenosfloat.a("valor"),astring );
        
        calculo(vmenosfloat.a("valor"), asignacionmenos);
        return vmenosfloat;
     }       
       
   
   /****************************** TIPOS *******************************************/
    
     public TAtributos tipos1(TAtributos dectipos) {
        regla("Tipos ->  tipos { DecTipos }");
        
        TAtributos tipos = atributosPara("TIPOSPROD","tsh","ts","err","tipo","mostrarErrores");
        
        dependencias(dectipos.a("tsh"),tipos.a("tsh"));
        
        dependencias(tipos.a("ts"),dectipos.a("ts"));
        dependencias(tipos.a("err"),dectipos.a("err"));
        dependencias(tipos.a("tipo"),dectipos.a("tipo"));
        dependencias(tipos.a("mostrarErrores"),dectipos.a("mostrarErrores"));
        
        calculo(dectipos.a("tsh"), asignacion);
        calculo(tipos.a("ts"), asignacion);  
        calculo(tipos.a("err"), copiaErrores);  
        calculo(tipos.a("tipo"), asignacion);  
        calculo(tipos.a("mostrarErrores"), asignacion);  
        
        return tipos;
     }   
   
     public TAtributos tipos2() {
        regla("Tipos ->  lamda");
        
        TAtributos tipos = atributosPara("TIPOSPROD","tsh","ts","err","tipo","mostrarErrores");
        
        dependencias(tipos.a("ts"),tipos.a("tsh"));
        
        calculo(tipos.a("ts"), asignacion);  
        calculo(tipos.a("err"), creaErrores);  
        calculo(tipos.a("tipo"), creaTipo); 
        calculo(tipos.a("mostrarErrores"), codMostrarErroresVacio);  
       
         return tipos;
     }        
     

public TAtributos dectipos0(TAtributos dectipos1,TAtributos dectipo) {
        regla("DecTipos ->  DecTipos ; DecTipo");
        
        TAtributos dectipos0 = atributosPara("DECTIPOS","tsh","ts","err","tipo","mostrarErrores");
        
        dependencias(dectipos1.a("tsh"),dectipos0.a("tsh"));
        dependencias(dectipo.a("tsh"),dectipos1.a("ts"));
        
        dependencias(dectipos0.a("err"),dectipos1.a("err"),dectipo.a("err"),dectipos1.a("ts"),dectipo.a("id"));
        dependencias(dectipos0.a("tipo"),dectipos1.a("tipo"),dectipo.a("tipo"));
        dependencias(dectipos0.a("ts"),dectipos1.a("ts"),dectipos0.a("err"),dectipo.a("id"),dectipo.a("clase"),dectipo.a("tipo"));
        dependencias(dectipos0.a("mostrarErrores"),dectipos1.a("mostrarErrores"),dectipo.a("mostrarErrores"),dectipos1.a("ts"),dectipo.a("id"),dectipo.a("filaCol"));
        
        calculo(dectipos1.a("tsh"), asignacion); 
        calculo(dectipo.a("tsh"), asignacion); 
       
        calculo(dectipos0.a("err"), unirErroresOrDuplicado);
        calculo(dectipos0.a("tipo"), unirDosTipos);  
        calculo(dectipos0.a("ts"), anadirTSTipo);
        calculo(dectipos0.a("mostrarErrores"), unirMostrarErroresOrDuplicado);
        
        return dectipos0;
     } 
     
   public TAtributos dectipos1(TAtributos dectipo) {
        regla("DecTipos → DecTipo");
        
        TAtributos dectipos = atributosPara("DECTIPOS","tsh","ts","err","tipo","mostrarErrores");
        
        dependencias(dectipo.a("tsh"),dectipos.a("tsh"));
        
        dependencias(dectipos.a("err"),dectipo.a("err"),dectipos.a("tsh"),dectipo.a("id"));
        dependencias(dectipos.a("mostrarErrores"),dectipo.a("mostrarErrores"),dectipos.a("tsh"),dectipo.a("id"),dectipo.a("filaCol"));
        dependencias(dectipos.a("tipo"),dectipo.a("tipo"));
        dependencias(dectipos.a("ts"),dectipos.a("tsh"),dectipos.a("err"),dectipo.a("id"),dectipo.a("clase"),dectipo.a("tipo"));
           
        calculo(dectipo.a("tsh"), asignacion); 
        
        calculo(dectipos.a("err"), copiaErroresOrDuplicado);
        calculo(dectipos.a("tipo"), asignacion);  
        calculo(dectipos.a("ts"), anadirTSTipo);
        calculo(dectipos.a("mostrarErrores"), copiaMostrarErroresOrDuplicado);
       
        return dectipos;
     } 

   
    public TAtributos dectipo(TAtributos tipo, Token iden) {
        regla("DecTipo → tipo Tipo identificador ");
        
        TAtributos dectipo = atributosPara("DECTIPO","tsh","id","clase","tipo","err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("STRING","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
                
        dependencias(tipo.a("tsh"),dectipo.a("tsh"));
        
        dependencias(dectipo.a("tipo"),tipo.a("tipo"));
        dependencias(dectipo.a("id"),identificador);
        dependencias(dectipo.a("err"),tipo.a("err"));
        dependencias(dectipo.a("filaCol"),filaCol);
        dependencias(dectipo.a("mostrarErrores"),tipo.a("mostrarErrores"));
        
        calculo(tipo.a("tsh"), asignacion); 
        
        calculo(dectipo.a("tipo"), asignacion);  
        calculo(dectipo.a("id"), asignacion);
        calculo(dectipo.a("clase"), claseTipo);
        calculo(dectipo.a("filaCol"), asignacion);
        calculo(dectipo.a("err"), copiaErrores);   
        calculo(dectipo.a("mostrarErrores"), asignacion);   
       
        return dectipo;
     } 

    public TAtributos tipo1(TAtributos tipobasico) {
        regla("Tipo→ tipoBasico ");
        
        TAtributos tipo = atributosPara("TIPOPROD", "tsh","tipo", "err", "filaCol","mostrarErrores");
        
        dependencias(tipo.a("tipo"),tipobasico.a("tipo"));
        
        calculo(tipo.a("tipo"), asignacion);
        calculo(tipo.a("err"), creaErrores);
        calculo(tipo.a("mostrarErrores"), codMostrarErroresVacio);
                
        return tipo;
    } 

    
    public TAtributos tipo2(Token iden) {
        regla("Tipo→ identificador ");
        
        TAtributos tipo = atributosPara("TIPOPROD", "tsh","tipo", "err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("STRING","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(tipo.a("tipo"),identificador,tipo.a("tsh"));
        dependencias(tipo.a("err"),identificador,tipo.a("tsh"));
        dependencias(tipo.a("mostrarErrores"),identificador,tipo.a("tsh"),tipo.a("filaCol"),tipo.a("tipo"));
        dependencias(tipo.a("filaCol"),filaCol);
        
        calculo(tipo.a("tipo"), tipoDeIdConTS);
        calculo(tipo.a("filaCol"), asignacion);
        calculo(tipo.a("err"), creaErroresTipoIdentificador);
        calculo(tipo.a("mostrarErrores"), creaMostrarErroresTipoIdentificador);
        
        return tipo;
    } 
    
    public TAtributos tipo3(TAtributos tipo1, Token iden) {
        regla("Tipo→ Tipo [identificador] ");

        TAtributos tipo0 = atributosPara("TIPOPROD", "tsh","tipo", "err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("STRING","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());

        dependencias(tipo1.a("tsh"),tipo0.a("tsh"));

        dependencias(tipo0.a("err"),tipo1.a("err"), identificador, tipo0.a("tsh"));
        dependencias(tipo0.a("mostrarErrores"),tipo1.a("mostrarErrores"), identificador, tipo0.a("tsh"),filaCol);
        dependencias(tipo0.a("tipo"),tipo0.a("tsh"),identificador,tipo1.a("tipo"));
        dependencias(tipo0.a("filaCol"),filaCol);

        calculo(tipo1.a("tsh"), asignacion);
        calculo(tipo0.a("tipo"), creaArrayIdentificador);
        calculo(tipo0.a("filaCol"), asignacion);
        calculo(tipo0.a("err"), creaErroresTipoArrayIdentificador);
        calculo(tipo0.a("mostrarErrores"), creaMostrarErroresTipoArrayIdentificador);

        return tipo0;
    }
    
    public TAtributos tipo4(TAtributos tipo1, Token vnat) {
        regla("Tipo→ Tipo [natural] ");

        TAtributos tipo0 = atributosPara("TIPOPROD", "tsh","tipo", "err","filaCol","mostrarErrores");
        Atributo vnatural = atributoLexicoPara("STRING","lex",vnat.lex());

        dependencias(tipo1.a("tsh"),tipo0.a("tsh"));

        dependencias(tipo0.a("tipo"),vnatural,tipo1.a("tipo"));
        dependencias(tipo0.a("err"),tipo1.a("err"));
        dependencias(tipo0.a("mostrarErrores"),tipo1.a("mostrarErrores"));
        
        calculo(tipo1.a("tsh"), asignacion);
        calculo(tipo0.a("tipo"), creaArray);
        calculo(tipo0.a("err"), copiaErrores);
        calculo(tipo0.a("mostrarErrores"), asignacion);

        return tipo0;
    }
    
    
    public TAtributos tipo5(TAtributos rtupla) {
        regla("Tipo→ ( tupla ) ");
        
        TAtributos tipo = atributosPara("TIPOPROD", "tsh","tipo", "err","filaCol","mostrarErrores");
                
        dependencias(rtupla.a("tsh"),tipo.a("tsh"));
                
        dependencias(tipo.a("tipo"), rtupla.a("campos"),rtupla.a("err"),rtupla.a("tipo"));
        dependencias(tipo.a("err"), rtupla.a("err"));
        dependencias(tipo.a("mostrarErrores"), rtupla.a("mostrarErrores"));
        
        calculo(rtupla.a("tsh"), asignacion);
        calculo(tipo.a("tipo"), creaTupla);
        calculo(tipo.a("err"), copiaErrores);
        calculo(tipo.a("mostrarErrores"), asignacion);
        
        return tipo;
    } 
    
    public TAtributos tipo6() {
        regla("Tipo→ ( ) ");

        TAtributos tipo = atributosPara("TIPOPROD","tsh", "tipo", "err","filaCol","mostrarErrores");

        calculo(tipo.a("tipo"), creaTuplaVacia);
        calculo(tipo.a("err"), creaErrores);
        calculo(tipo.a("mostrarErrores"), codMostrarErroresVacio);

        return tipo;
    }
    
    public TAtributos rtupla1(TAtributos rtupla1, TAtributos tipo) {
        regla("RTupla → RTupla, Tipo ");

        TAtributos rtupla0 = atributosPara("TIPOPROD", "tsh","tipo","campos","desp","err","mostrarErrores");

        dependencias(rtupla1.a("tsh"), rtupla0.a("tsh"));
        dependencias(tipo.a("tsh"), rtupla0.a("tsh"));

        dependencias(rtupla0.a("tipo"), rtupla1.a("tipo"), tipo.a("tipo"));
        dependencias(rtupla0.a("err"), rtupla1.a("err"), tipo.a("err"));
        dependencias(rtupla0.a("mostrarErrores"), rtupla1.a("mostrarErrores"), tipo.a("mostrarErrores"));
        dependencias(rtupla0.a("campos"), rtupla1.a("campos"), tipo.a("tipo"), rtupla1.a("desp"));
        dependencias(rtupla0.a("desp"), rtupla1.a("desp"), tipo.a("tipo"));

        calculo(rtupla1.a("tsh"), asignacion);
        calculo(tipo.a("tsh"), asignacion);

        calculo(rtupla0.a("tipo"), unirDosTipos);
        calculo(rtupla0.a("err"), unirDosErrores);
        calculo(rtupla0.a("mostrarErrores"), unirMostrarDosErrores); 
        calculo(rtupla0.a("desp"), sumaDespConTamTipo);
        calculo(rtupla0.a("campos"), anadirCampoTupla); 

        return rtupla0;
    }
    
    public TAtributos rtupla2(TAtributos tipo) {
        regla("RTupla -> Tipo ");

        TAtributos rtupla = atributosPara("TIPOPROD","tsh","tipo","campos","desp","err","mostrarErrores");

        dependencias(tipo.a("tsh"), rtupla.a("tsh"));

        dependencias(rtupla.a("tipo"), tipo.a("tipo"));
        dependencias(rtupla.a("campos"), tipo.a("tipo"));
        dependencias(rtupla.a("desp"), tipo.a("tipo"));
        dependencias(rtupla.a("err"), tipo.a("err"));
        dependencias(rtupla.a("mostrarErrores"), tipo.a("mostrarErrores"));

        calculo(tipo.a("tsh"), asignacion);
        calculo(rtupla.a("tipo"), asignacion);
        calculo(rtupla.a("campos"), primerCampoTupla);
        calculo(rtupla.a("desp"), dameTamTipo);
        calculo(rtupla.a("err"), copiaErrores);
        calculo(rtupla.a("mostrarErrores"), asignacion);

        return rtupla;
    }
    
    public TAtributos tipobasicoNat() {
        regla("TipoBasico → natural ");
        
        TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo","filaCol");
        
         calculo(tipoBasico.a("tipo"), creaNatural);
         return tipoBasico;
    } 
  
    public TAtributos tipobasicoInt() {
        regla("TipoBasico → int ");
        
        TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo","filaCol");
        
         calculo(tipoBasico.a("tipo"), creaInt);
         return tipoBasico;
    }
    
    public TAtributos tipobasicoChar() {
        regla("TipoBasico → char ");
        
        TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo","filaCol");
        
         calculo(tipoBasico.a("tipo"), creaChar);
         return tipoBasico;
    } 
       
    public TAtributos tipobasicoFloat() {
        regla("TipoBasico → float ");
        
        TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo","filaCol");
        
         calculo(tipoBasico.a("tipo"), creaFloat);
         return tipoBasico;
    } 
   
    public TAtributos tipobasicoBool() {
        regla("TipoBasico → bool ");
        
        TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo","filaCol");
        
         calculo(tipoBasico.a("tipo"), creaBool);
         return tipoBasico;
    } 
    
 
    /*********************** variables ************************/   
       
   public TAtributos variables1(TAtributos decvars) {
        regla("Variables ->  vars { DecVars }");
        
        TAtributos variables1 = atributosPara("VARIABLES", "tsh","dirh","ts","err","tipo","dir","mostrarErrores"); 
       
        dependencias(decvars.a("tsh"),variables1.a("tsh"));
        dependencias(decvars.a("dirh"),variables1.a("dirh"));
        
        dependencias(variables1.a("ts"),decvars.a("ts"));
        dependencias(variables1.a("err"),decvars.a("err"));
        dependencias(variables1.a("mostrarErrores"),decvars.a("mostrarErrores"));
        dependencias(variables1.a("tipo"),decvars.a("tipo"));
        dependencias(variables1.a("dir"),decvars.a("dir"));
        
        calculo(decvars.a("tsh"), asignacion);
        calculo(decvars.a("dirh"), asignacion);
        
        calculo(variables1.a("ts"), asignacion);
        calculo(variables1.a("err"), copiaErrores);
        calculo(variables1.a("mostrarErrores"), asignacion);
        calculo(variables1.a("tipo"), asignacion);
        calculo(variables1.a("dir"), asignacion);
        
        return variables1;
     }    
         
   public TAtributos variables2( ) {
        regla("Variables ->  lambda");
        
        TAtributos variables2 = atributosPara("VARIABLES","tsh","dirh","ts","err","tipo","dir","mostrarErrores");
        
        dependencias(variables2.a("ts"),variables2.a("tsh"));
        dependencias(variables2.a("dir"),variables2.a("dirh"));
        
        calculo(variables2.a("ts"), asignacion);
        calculo(variables2.a("err"), creaErrores);
        calculo(variables2.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(variables2.a("tipo"), creaTipo);
        calculo(variables2.a("dir"), asignacion);
        
        return variables2;
     } 
   
   public TAtributos decvars0(TAtributos decvars1,TAtributos decvar) {
        regla("DecVars ->  DecVars ; DecVar");
        
        TAtributos decvars0 = atributosPara("DECVARS","tsh","dirh","err","tipo","dir","ts","mostrarErrores");
        
        dependencias(decvars1.a("dirh"),decvars0.a("dirh"));
        dependencias(decvar.a("tsh"),decvars0.a("tsh"));
        dependencias(decvars1.a("tsh"),decvars0.a("tsh"));
        
        dependencias(decvars0.a("err"),decvars1.a("err"),decvar.a("err"),decvars1.a("ts"),decvar.a("id"));
        dependencias(decvars0.a("mostrarErrores"),decvars1.a("mostrarErrores"),decvar.a("mostrarErrores"),decvars1.a("ts"),decvar.a("id"),decvar.a("filaCol"));
        dependencias(decvars0.a("tipo"),decvars1.a("tipo"),decvar.a("tipo"));
        dependencias(decvars0.a("dir"),decvars1.a("dir"),decvar.a("tipo"),decvar.a("clase"));
        dependencias(decvars0.a("ts"),decvars1.a("ts"),decvars0.a("err"),decvar.a("id"),decvar.a("clase"),decvar.a("tipo"),decvars1.a("dir"));
        
        calculo(decvars1.a("dirh"), asignacion); 
        calculo(decvar.a("tsh"), asignacion);
        calculo(decvars1.a("tsh"), asignacion);
       
        calculo(decvars0.a("err"), unirErroresOrDuplicado);
        calculo(decvars0.a("mostrarErrores"), unirMostrarErroresOrDuplicado);
        calculo(decvars0.a("tipo"), unirDosTipos);
        calculo(decvars0.a("dir"), sumaDirConTam);
        calculo(decvars0.a("ts"), anadirTS);
        
        return decvars0;
     } 
    
   public TAtributos decvars1(TAtributos decvar) {
        regla("DecVars → DecVar");
        
        TAtributos decvars = atributosPara("DECVARS", "tsh", "dirh", "err","tipo","dir","ts","mostrarErrores");
        
        dependencias(decvar.a("tsh"),decvars.a("tsh"));

        dependencias(decvars.a("err"),decvar.a("err"),decvars.a("tsh"),decvar.a("id"));
        dependencias(decvars.a("mostrarErrores"),decvar.a("mostrarErrores"),decvars.a("tsh"),decvar.a("id"),decvar.a("filaCol"));
        dependencias(decvars.a("tipo"),decvar.a("tipo"));
        dependencias(decvars.a("dir"),decvars.a("dirh"),decvar.a("tipo"),decvar.a("clase"));
        dependencias(decvars.a("ts"),decvars.a("tsh"),decvars.a("err"),decvar.a("id"),decvar.a("clase"),decvar.a("tipo"),decvars.a("dirh"));

        calculo(decvar.a("tsh"), asignacion);
       
        calculo(decvars.a("err"), copiaErroresOrDuplicado);
        calculo(decvars.a("mostrarErrores"), copiaMostrarErroresOrDuplicado);
        calculo(decvars.a("tipo"), asignacion);
        calculo(decvars.a("dir"), sumaDirConTam);
        calculo(decvars.a("ts"), anadirTS);       
        
         return decvars;
     } 

       public TAtributos decvar(TAtributos tipo,Token iden) {
        regla("DecVar → var Tipo identificador ");
        
        TAtributos decvar = atributosPara("DECVAR", "tsh","id","clase","tipo","err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("STRING","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(tipo.a("tsh"),decvar.a("tsh") );
        dependencias(decvar.a("id"), identificador);
        dependencias(decvar.a("tipo"),tipo.a("tipo"));        
        dependencias(decvar.a("err"),tipo.a("err"));
        dependencias(decvar.a("mostrarErrores"),tipo.a("mostrarErrores"));
        dependencias(decvar.a("filaCol"),filaCol);
       
        calculo(tipo.a("tsh"), asignacion);
        calculo(decvar.a("id"), asignacion);
        calculo(decvar.a("clase"), claseVar);
        calculo(decvar.a("tipo"), asignacion);
        calculo(decvar.a("err"), copiaErrores);
        calculo(decvar.a("mostrarErrores"), asignacion);
        calculo(decvar.a("filaCol"), asignacion);
        
        return decvar;
     } 
     
 /********************* SUBPROGRAMAS ***************************************/
    
    public TAtributos subprograms0(TAtributos decssubprograms) {
        regla("Subprogramas -> subprograms { DecsSubprogramas }");
        
        TAtributos subprograms = atributosPara("SUBPROGRAMS", "tsh","etqh","ts","etq","cod","err","tipo","mostrarErrores");
        
        dependencias(decssubprograms.a("tsh"),subprograms.a("tsh"));
        dependencias(decssubprograms.a("etqh"), subprograms.a("etqh"));
        
        dependencias(subprograms.a("etq"),decssubprograms.a("etq"));
        dependencias(subprograms.a("ts"),decssubprograms.a("ts"));
        dependencias(subprograms.a("err"),decssubprograms.a("err"));
        dependencias(subprograms.a("mostrarErrores"),decssubprograms.a("mostrarErrores"));
        dependencias(subprograms.a("tipo"),decssubprograms.a("tipo"));
        dependencias(subprograms.a("cod"),decssubprograms.a("cod"), subprograms.a("err") ,subprograms.a("tipo"));
          
        calculo(decssubprograms.a("tsh"), asignacion);
        calculo(decssubprograms.a("etqh"), asignacion);
        
        calculo(subprograms.a("etq"), asignacion);
        calculo(subprograms.a("ts"), asignacion);
        calculo(subprograms.a("err"), copiaErrores);
        calculo(subprograms.a("mostrarErrores"), asignacion);
        calculo(subprograms.a("tipo"), asignacion);
        calculo(subprograms.a("cod"), copiaCodigo);
        
        return subprograms;
     }
    
    
    public TAtributos subprograms1() {
        regla("Subprograms -> lambda ");
        
        TAtributos subprograms = atributosPara("SUBPROGRAMAS","tsh","etqh","etq","cod","ts","err","tipo","mostrarErrores");  
        
        dependencias(subprograms.a("etq"),subprograms.a("etqh"));
        dependencias(subprograms.a("ts"),subprograms.a("tsh"));
        
        calculo(subprograms.a("etq"), asignacion);
        calculo(subprograms.a("ts"), asignacion); //Asignacion
        calculo(subprograms.a("cod"), codVacio);        
        calculo(subprograms.a("err"), creaErrores);
        calculo(subprograms.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(subprograms.a("tipo"), creaTipo);
                
        return subprograms; 
     } 
    
    
    
    public TAtributos decsubprograms0(TAtributos decsubprograms1, TAtributos decsubprogram) {
        regla("DecSubprograms -> DecSubprograms ; DecSubprogram ");
        
        TAtributos decsubprograms0 = atributosPara("DECSUBPROGRAMS", "tsh","etqh","etq","cod","ts","err", "tipo","mostrarErrores"); 
        
        
        dependencias(decsubprograms1.a("tsh"),decsubprograms0.a("tsh"));
	dependencias(decsubprogram.a("tsh"),decsubprograms1.a("ts"));
        dependencias(decsubprograms1.a("etqh"), decsubprograms0.a("etqh"));
        dependencias(decsubprogram.a("etqh"), decsubprograms1.a("etq"));
        
        dependencias(decsubprograms0.a("etq"),decsubprogram.a("etq"));
        dependencias(decsubprograms0.a("cod"),decsubprograms1.a("cod"),decsubprogram.a("cod"));
	dependencias(decsubprograms0.a("err"),decsubprograms1.a("err"),decsubprogram.a("err"));
        dependencias(decsubprograms0.a("mostrarErrores"),decsubprograms1.a("mostrarErrores"),decsubprogram.a("mostrarErrores"));
        dependencias(decsubprograms0.a("ts"),decsubprograms1.a("ts"),decsubprograms0.a("err"),decsubprogram.a("id"),decsubprogram.a("clase"),decsubprogram.a("tipo"),decsubprograms1.a("etq"));
        dependencias(decsubprograms0.a("tipo"),decsubprograms1.a("tipo"),decsubprogram.a("tipo"));
        
        calculo(decsubprograms1.a("tsh"), creaTSLocal);
        calculo(decsubprogram.a("tsh"), creaTSLocal);
        calculo(decsubprograms1.a("etqh"), asignacion);
        calculo(decsubprogram.a("etqh"), asignacion);
		
        calculo(decsubprograms0.a("etq"), asignacion);
        calculo(decsubprograms0.a("cod"), concatenaDosCod);
        calculo(decsubprograms0.a("err"), unirDosErrores); 
        calculo(decsubprograms0.a("mostrarErrores"), unirMostrarDosErrores); 
        calculo(decsubprograms0.a("ts"),  anadirTSYBorraLocal);
        calculo(decsubprograms0.a("tipo"), unirDosTipos);
   
        return decsubprograms0;    
     } 
    
    public TAtributos decsubprograms1(TAtributos decsubprogram) {
        regla("DecSubprograms -> DecSubprogram ");
        
        TAtributos decsubprograms = atributosPara("DECSUBPROGRAMS","tsh","etqh","etq","cod","ts","err", "tipo","mostrarErrores"); 
                                                    
        dependencias(decsubprogram.a("tsh"),decsubprograms.a("tsh"));
        dependencias(decsubprogram.a("etqh"), decsubprograms.a("etqh"));
        
        dependencias(decsubprograms.a("etq"),decsubprogram.a("etq"));
	dependencias(decsubprograms.a("err"),decsubprogram.a("err"));
        dependencias(decsubprograms.a("mostrarErrores"),decsubprogram.a("mostrarErrores"));
        dependencias(decsubprograms.a("tipo"),decsubprogram.a("tipo"));
        dependencias(decsubprograms.a("ts"),decsubprograms.a("tsh"),decsubprograms.a("err"),decsubprogram.a("id"),decsubprogram.a("clase"),decsubprograms.a("tipo"),decsubprograms.a("etqh"));
        dependencias(decsubprograms.a("cod"),decsubprogram.a("cod"),decsubprograms.a("err"),decsubprograms.a("tipo"));
        
        calculo(decsubprogram.a("tsh"), creaTSLocal);
        calculo(decsubprogram.a("etqh"), asignacion);
	
        calculo(decsubprograms.a("etq"), asignacion);
        calculo(decsubprograms.a("err"), copiaErrores); 
        calculo(decsubprograms.a("mostrarErrores"), asignacion); 
        calculo(decsubprograms.a("tipo"), asignacion); 
        calculo(decsubprograms.a("ts"),  anadirTSYBorraLocal);

        calculo(decsubprograms.a("cod"), copiaCodigo);
   
        return decsubprograms;    
     } 

    public TAtributos subprogram(Token iden, TAtributos parametros, TAtributos cuerposub) {
        regla("DecSubprogram -> subprogram : id (ParametrosSub) { CuerpoSub } →  ");
        
        TAtributos decsubprogram = atributosPara("DECSUBPROGRAM", "tsh","etqh","etq","cod","err","clase","id","tipo","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(parametros.a("tsh"), decsubprogram.a("tsh"));
        dependencias(cuerposub.a("dirh"), parametros.a("dir"));
        dependencias(cuerposub.a("tsh"), parametros.a("ts"));
        dependencias(cuerposub.a("etqh"), decsubprogram.a("etqh"));
        
	dependencias(decsubprogram.a("id"),identificador);
        dependencias(decsubprogram.a("filaCol"),identificador);
        dependencias(decsubprogram.a("err"),parametros.a("err"),cuerposub.a("err"),identificador,decsubprogram.a("tsh"));
        dependencias(decsubprogram.a("mostrarErrores"),parametros.a("mostrarErrores"),cuerposub.a("mostrarErrores"),identificador,decsubprogram.a("tsh"),decsubprogram.a("filaCol"));
        dependencias(decsubprogram.a("tipo"),parametros.a("lista"),identificador,parametros.a("tipo"),cuerposub.a("tipo"));
        dependencias(decsubprogram.a("etq"),cuerposub.a("etq"));   
        dependencias(decsubprogram.a("cod"),cuerposub.a("cod"), decsubprogram.a("err"),decsubprogram.a("tipo"));
       
        calculo(parametros.a("tsh"),asignacion );
        calculo(cuerposub.a("dirh"),asignacion );
	calculo(cuerposub.a("tsh"),asignacion );
        calculo(cuerposub.a("etqh"), asignacion);
		
        calculo(decsubprogram.a("clase"),claseSubprograma);
        calculo(decsubprogram.a("id"),asignacion);
        calculo(decsubprogram.a("filaCol"),asignacion);
        calculo(decsubprogram.a("err"), unirErroresDecSubprogram);
        calculo(decsubprogram.a("mostrarErrores"), unirMostrarErroresDecSubprogram);
        calculo(decsubprogram.a("tipo"),crearProc);		
        calculo(decsubprogram.a("etq"),asignacion);
        calculo(decsubprogram.a("cod"),copiaCodigo);
        
        return decsubprogram;   
     }     
    
    public TAtributos parametrosSub0(TAtributos params) {
        regla("ParametrosSub -> ParametrosFSub");
        
        TAtributos parametrosSub0 = atributosPara("PARAMETROSSUB","tsh","tipo","ts","err","lista", "dir","mostrarErrores");
        
        dependencias(params.a("tsh"),parametrosSub0.a("tsh"));
        
	dependencias(parametrosSub0.a("dir"),params.a("dir"));
	dependencias(parametrosSub0.a("err"),params.a("err"));
        dependencias(parametrosSub0.a("mostrarErrores"),params.a("mostrarErrores"));
        dependencias(parametrosSub0.a("tipo"),params.a("tipo"));
        dependencias(parametrosSub0.a("lista"),params.a("lista"));
        dependencias(parametrosSub0.a("ts"),params.a("ts"));
        
        calculo(params.a("tsh"),asignacion);
        
	calculo(parametrosSub0.a("dir"),asignacion);
	calculo(parametrosSub0.a("err"),copiaErrores);
        calculo(parametrosSub0.a("mostrarErrores"),asignacion);
        calculo(parametrosSub0.a("tipo"),asignacion);
        calculo(parametrosSub0.a("lista"),copiaLista);
        calculo(parametrosSub0.a("ts"),asignacion);
        
        return parametrosSub0;
     }   
    
    public TAtributos parametrosSub1() {
        regla("ParametrosSub -> lambda");
        
        TAtributos parametrosSub = atributosPara("PARAMETROSSUB","tsh", "lista","tipo","ts","err", "dir","mostrarErrores");
        
        dependencias(parametrosSub.a("ts"),parametrosSub.a("tsh"));
 
        calculo(parametrosSub.a("lista"),crearListaVacia);
	calculo(parametrosSub.a("ts"),asignacion);
	calculo(parametrosSub.a("err"),creaErrores);
	calculo(parametrosSub.a("dir"),asignacion0);
        calculo(parametrosSub.a("tipo"),creaTipo);
        calculo(parametrosSub.a("mostrarErrores"),codMostrarErroresVacio);
        
        return parametrosSub;
     } 
  
    
    public TAtributos parametrosFSub0(TAtributos parametrosFSub1, TAtributos param) {
        regla("ParametrosFSub -> ParametrosFSub, ParametroFSub");
        
        TAtributos parametrosFSub0 = atributosPara("PARAMETROSFSUB","tsh", "lista","dir","ts","err", "tipo","desp","mostrarErrores");
        
        dependencias(parametrosFSub1.a("tsh"),parametrosFSub0.a("tsh"));
	dependencias(param.a("tsh"),parametrosFSub1.a("ts"));
        
	dependencias(parametrosFSub0.a("err"),parametrosFSub1.a("err"),param.a("err"), parametrosFSub1.a("ts"), param.a("id"));
	dependencias(parametrosFSub0.a("mostrarErrores"),parametrosFSub1.a("mostrarErrores"),param.a("mostrarErrores"), parametrosFSub1.a("ts"), param.a("id"),param.a("filaCol"));	
        dependencias(parametrosFSub0.a("ts"),parametrosFSub1.a("ts"),param.a("err"),param.a("id"),param.a("clase"),param.a("tipo"),parametrosFSub1.a("dir"));
	dependencias(parametrosFSub0.a("dir"),parametrosFSub1.a("dir"),param.a("tipo"),param.a("clase"));
        dependencias(parametrosFSub0.a("tipo"),parametrosFSub1.a("tipo"),param.a("tipo"));
        dependencias(parametrosFSub0.a("desp"),parametrosFSub1.a("desp"),param.a("tipo"),param.a("modo"));
        dependencias(parametrosFSub0.a("lista"),parametrosFSub1.a("lista"),param.a("id"),param.a("modo"),param.a("tipo"),parametrosFSub1.a("desp"),parametrosFSub1.a("dir"));
        
        calculo(parametrosFSub1.a("tsh"),asignacion);
	calculo(param.a("tsh"),asignacion);
        
        calculo(parametrosFSub0.a("err"),unirErroresParametrosFSub);
        calculo(parametrosFSub0.a("mostrarErrores"),unirMostrarErroresParametrosFSub);
        calculo(parametrosFSub0.a("ts"), anadirTS);
        calculo(parametrosFSub0.a("dir"),sumaDirConTam);
        calculo(parametrosFSub0.a("tipo"),unirDosTipos);
        calculo(parametrosFSub0.a("desp"),sumaDespConTamTipoProc);
        calculo(parametrosFSub0.a("lista"),anadirCampoProc);
                
        return parametrosFSub0;
     }   
   
    
    public TAtributos parametrosFSub1(TAtributos parametroF) {
        regla("ParametrosFSub -> ParametroFSub");
        
        TAtributos parametrosFSub = atributosPara("PARAMETROSFSUB","tsh", "lista","dir","ts","err", "tipo","desp","mostrarErrores");
        
	dependencias(parametroF.a("tsh"),parametrosFSub.a("tsh"));
        
	dependencias(parametrosFSub.a("err"),parametroF.a("err"));
        dependencias(parametrosFSub.a("mostrarErrores"),parametroF.a("mostrarErrores"));
	dependencias(parametrosFSub.a("ts"),parametrosFSub.a("tsh"),parametroF.a("err"),parametroF.a("id"),parametroF.a("clase"),parametroF.a("tipo"));
        dependencias(parametrosFSub.a("lista"),parametroF.a("id"),parametroF.a("modo"),parametroF.a("tipo"));
	dependencias(parametrosFSub.a("dir"),parametroF.a("tipo"),parametroF.a("clase"));
        dependencias(parametrosFSub.a("tipo"),parametroF.a("tipo"));
        dependencias(parametrosFSub.a("desp"),parametroF.a("tipo"),parametroF.a("modo"));
        
	calculo(parametroF.a("tsh"),asignacion);
        
        calculo(parametrosFSub.a("err"),copiaErrores);
        calculo(parametrosFSub.a("mostrarErrores"),asignacion);
        calculo(parametrosFSub.a("ts"), anadirTSDir0);
        calculo(parametrosFSub.a("lista"),anadirCampoProcCreaLista);
        calculo(parametrosFSub.a("dir"),dirConTam);
        calculo(parametrosFSub.a("tipo"),asignacion);
        calculo(parametrosFSub.a("desp"),sumaPrimerDespConTamTipoProc);
        
        return parametrosFSub;
     }     
    
    
    
    public TAtributos parametroFSub0(TAtributos tipo, Token iden ) {
        regla("ParametroFSub -> Tipo Identificador ");
        
        TAtributos parametroFSub = atributosPara("PARAMETROFSUB", "tsh", "id", "tipo", "clase", "modo", "err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(tipo.a("tsh"),parametroFSub.a("tsh"));
        
        dependencias(parametroFSub.a("id"),identificador);
        dependencias(parametroFSub.a("filaCol"),filaCol);
        dependencias(parametroFSub.a("tipo"),tipo.a("tipo"));
        dependencias(parametroFSub.a("err"),tipo.a("err"));
        dependencias(parametroFSub.a("mostrarErrores"),tipo.a("mostrarErrores"));
 
        calculo(tipo.a("tsh"),asignacion);
        
        calculo(parametroFSub.a("id"),asignacion);
        calculo(parametroFSub.a("filaCol"),asignacion);
        calculo(parametroFSub.a("clase"),claseVar);
        calculo(parametroFSub.a("modo"),modoValor);
	calculo(parametroFSub.a("err"),copiaErrores);
        calculo(parametroFSub.a("mostrarErrores"),asignacion);
        calculo(parametroFSub.a("tipo"),asignacion);
        
        return parametroFSub;
     }     
    
    public TAtributos parametroFSub1(TAtributos tipo, Token iden) {
        regla("ParametrosF -> Tipo * Identificador");
        
        TAtributos parametroFSub = atributosPara("PARAMETROFSUB", "tsh", "id", "tipo", "clase", "modo", "err","filaCol","mostrarErrores");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(tipo.a("tsh"),parametroFSub.a("tsh"));
        
        dependencias(parametroFSub.a("id"),identificador);
        dependencias(parametroFSub.a("filaCol"),filaCol);
        dependencias(parametroFSub.a("tipo"),tipo.a("tipo"));
        dependencias(parametroFSub.a("err"),tipo.a("err"));
        dependencias(parametroFSub.a("mostrarErrores"),tipo.a("mostrarErrores"));
 
        calculo(tipo.a("tsh"),asignacion);
        
        calculo(parametroFSub.a("id"),asignacion);
        calculo(parametroFSub.a("filaCol"),asignacion);
        calculo(parametroFSub.a("clase"),clasePVar);
        calculo(parametroFSub.a("modo"),modoVar);
	calculo(parametroFSub.a("err"),copiaErrores);
        calculo(parametroFSub.a("mostrarErrores"),asignacion);
        calculo(parametroFSub.a("tipo"),asignacion);
        
        return parametroFSub;
     }  
    
    
    
    public TAtributos cuerpoSub(TAtributos variables, TAtributos instrucciones) {
        regla("CuerpoSub -> Variables Instrucciones");
        
        TAtributos cuerpoSub = atributosPara("CUERPOSUB", "tsh", "etqh", "dirh", "ts", "err", "tipo", "cod", "etq","mostrarErrores");
        
        dependencias(variables.a("tsh"),cuerpoSub.a("tsh"));
        dependencias(variables.a("dirh"),cuerpoSub.a("dirh"));
        dependencias(instrucciones.a("tsh"),variables.a("ts"));
        dependencias(instrucciones.a("etqh"),cuerpoSub.a("etqh"));
        
        dependencias(cuerpoSub.a("err"),variables.a("err"),instrucciones.a("err"));
        dependencias(cuerpoSub.a("mostrarErrores"),variables.a("mostrarErrores"),instrucciones.a("mostrarErrores"));
        dependencias(cuerpoSub.a("tipo"),variables.a("tipo"),instrucciones.a("tipo"));
        dependencias(cuerpoSub.a("ts"),variables.a("ts"));
        dependencias(cuerpoSub.a("etq"),instrucciones.a("etq"));
        dependencias(cuerpoSub.a("cod"),instrucciones.a("cod"),variables.a("dir"));
        
        calculo(variables.a("tsh"),asignacion);
        calculo(variables.a("dirh"),asignacion);
        calculo(instrucciones.a("tsh"),asignacion);
        calculo(instrucciones.a("etqh"),asignacionSuma13);
        
	calculo(cuerpoSub.a("err"),unirDosErrores);
        calculo(cuerpoSub.a("mostrarErrores"),unirMostrarDosErrores);
        calculo(cuerpoSub.a("tipo"),unirDosTipos);
        calculo(cuerpoSub.a("ts"),asignacion);
        calculo(cuerpoSub.a("etq"),asignacionSuma14);
	calculo(cuerpoSub.a("cod"),codigoCuerpoSub);
       
        return cuerpoSub;
     }     
    
  /**********************   INSTRUCCIONES *************************************/     
       
    public TAtributos instrucciones(TAtributos insts) {
        regla("Instrucciones → { Insts} ");
        
        TAtributos instrucciones = atributosPara("INSTRUCCIONES", "tsh","etqh","err","tipo","cod","etq","mostrarErrores");
        
        dependencias(insts.a("tsh"),instrucciones.a("tsh"));
        dependencias(insts.a("etqh"),instrucciones.a("etqh"));
        dependencias(instrucciones.a("tipo"),insts.a("tipo"));
        dependencias(instrucciones.a("err"),insts.a("err"));
        dependencias(instrucciones.a("cod"),insts.a("cod"),insts.a("err"),insts.a("tipo"));
        dependencias(instrucciones.a("etq"),insts.a("etq"));
        dependencias(instrucciones.a("mostrarErrores"),insts.a("mostrarErrores"));
        
        calculo(insts.a("tsh"), asignacion);
        calculo(insts.a("etqh"), asignacion);
        
        calculo(instrucciones.a("tipo"), asignacion);
        calculo(instrucciones.a("err"), copiaErrores);
        calculo(instrucciones.a("cod"), copiaCodigo);
        calculo(instrucciones.a("etq"), asignacion);
        calculo(instrucciones.a("mostrarErrores"), asignacion); 
        return instrucciones;
     } 
        
        
    
/****************************** INSTS *********************************/  
  
    
    public TAtributos insts0(TAtributos insts1, TAtributos inst) {
        regla("Insts -> Insts:insts ; Inst:inst →  ");
        
        TAtributos insts0 = atributosPara("INSTS","tsh","etqh","etq","err","tipo","cod","mostrarErrores");
        
        dependencias(insts1.a("tsh"),insts0.a("tsh"));
        dependencias(insts1.a("etqh"),insts0.a("etqh"));        
        dependencias(inst.a("tsh"),insts0.a("tsh"));
        dependencias(inst.a("etqh"),insts1.a("etq"));
        
        dependencias(insts0.a("tipo"),insts1.a("tipo"), inst.a("tipo"));
        dependencias(insts0.a("err"),insts1.a("err"),inst.a("err"));        
        dependencias(insts0.a("cod"),insts1.a("cod"), inst.a("cod"), insts0.a("err"), insts0.a("tipo"));
        dependencias(insts0.a("etq"),inst.a("etq"));
        dependencias(insts0.a("mostrarErrores"),insts1.a("mostrarErrores"),inst.a("mostrarErrores"));     
        
        calculo(insts1.a("tsh"), asignacion);
        calculo(insts1.a("etqh"), asignacion);
        
        calculo(inst.a("tsh"), asignacion);
        calculo(inst.a("etqh"), asignacion);
        
        calculo(insts0.a("tipo"), unirDosTipos);
        calculo(insts0.a("err"), unirDosErrores);
        calculo(insts0.a("cod"), concatenaCodInsts);
        calculo(insts0.a("etq"), asignacion);
        calculo(insts0.a("mostrarErrores"), unirMostrarDosErrores);
        
        return insts0;
        
     } 
      //revisado
    public TAtributos insts1(TAtributos inst) {
        regla("Insts -> Inst:inst");
        
        TAtributos insts = atributosPara("INSTS","tsh","etqh","etq","err","tipo","cod","mostrarErrores");
        
        dependencias(inst.a("etqh"),insts.a("etqh"));
        dependencias(inst.a("tsh"),insts.a("tsh"));
        
        dependencias(insts.a("err"),inst.a("err"));
        dependencias(insts.a("mostrarErrores"),inst.a("mostrarErrores"));
        dependencias(insts.a("tipo"),inst.a("tipo"));
        dependencias(insts.a("etq"),inst.a("etq"));
        dependencias(insts.a("cod"),inst.a("cod"), insts.a("err"), inst.a("tipo"));
        
        calculo(inst.a("etqh"), asignacion);
        calculo(inst.a("tsh"), asignacion);
        
        calculo(insts.a("etq"), asignacion);
        calculo(insts.a("err"), copiaErrores);
        calculo(insts.a("mostrarErrores"), asignacion);
        calculo(insts.a("cod"), copiaCodigo);
        calculo(insts.a("tipo"), asignacion);
        
        return insts;
     }

/****************************** INST *********************************/  

   public TAtributos instDesig(TAtributos desig, TAtributos exp) {
        regla("Inst -> Designador = Exp");        
           
        TAtributos inst = atributosPara("INST","tsh","etqh","irvh","irfh","tipo","err","cod","etq","mostrarErrores");
        
        dependencias(exp.a("tsh"),inst.a("tsh"));
        dependencias(desig.a("tsh"),inst.a("tsh"));
        dependencias(desig.a("etqh"),inst.a("etqh"));
        dependencias(exp.a("etqh"),desig.a("etq"));
        
        dependencias(inst.a("tipo"),desig.a("tipo"),exp.a("tipo"),exp.a("tsh"));
        dependencias(inst.a("etq"),exp.a("etq"),exp.a("esDesig"),inst.a("tipo"));
        dependencias(inst.a("err"),inst.a("tsh"),desig.a("id"),desig.a("err"),exp.a("err"));
        dependencias(inst.a("cod"),desig.a("cod"),exp.a("cod"),exp.a("esDesig"), inst.a("tipo"));
        dependencias(inst.a("mostrarErrores"),inst.a("tsh"),desig.a("id"),desig.a("mostrarErrores"),exp.a("mostrarErrores"),desig.a("tipo"),exp.a("tipo"),desig.a("filaCol"));

        dependencias(exp.a("irvh"),inst.a("etqh"));
        dependencias(exp.a("irfh"),inst.a("etqh"));
        
        calculo(exp.a("tsh"), asignacion);
        calculo(desig.a("tsh"), asignacion);
        calculo(desig.a("etqh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        
        calculo(inst.a("tipo"), tiposCompatibles);
        calculo(inst.a("etq"), sumaEtqDesignadorMas1DesigExp);
        calculo(inst.a("err"), errDesignadorInst);        
        calculo(inst.a("cod"), codDesignadorInst);
        calculo(inst.a("mostrarErrores"), mostrarErroresDesignadorInst);   
        
        calculo(exp.a("irvh"), asignacion);
        calculo(exp.a("irfh"), asignacion);

        return inst;
     } 
   //revisada 
   public TAtributos instSwap1() {
        regla("Inst -> swap1");
        
        TAtributos inst = atributosPara("INST","tsh","etqh", "cod","etq","tipo","err","mostrarErrores");
        
        dependencias(inst.a("etq"),inst.a("etqh"));        
        
        calculo(inst.a("cod"), creaCodSwap1);
        calculo(inst.a("etq"), asignacionSuma1);
        calculo(inst.a("tipo"), creaTipo);
        calculo(inst.a("err"), creaErrores);
        calculo(inst.a("mostrarErrores"), codMostrarErroresVacio);
        
        return inst;
     } 
   //revisada
   public TAtributos instSwap2() {
        regla("Inst -> swap2");
        
        TAtributos inst = atributosPara("INST","tsh","etqh", "cod","etq","tipo","err","mostrarErrores");
        
        dependencias(inst.a("etq"),inst.a("etqh"));
                
        calculo(inst.a("cod"), creaCodSwap2);
        calculo(inst.a("etq"), asignacionSuma1);
        calculo(inst.a("tipo"), creaTipo);
        calculo(inst.a("err"), creaErrores);
        calculo(inst.a("mostrarErrores"), codMostrarErroresVacio);
        
        return inst;
     } 
   
   public TAtributos instIn(TAtributos desig) {
        regla("Inst -> in (Designador)" );
        
        TAtributos inst = atributosPara("INST","tsh","etqh", "cod","etq","tipo","err","mostrarErrores");
        
        dependencias(desig.a("tsh"),inst.a("tsh"));
        dependencias(desig.a("etqh"),inst.a("etqh"));
        
        dependencias(inst.a("tipo"),desig.a("tipo"),inst.a("tsh"));
        dependencias(inst.a("err"),desig.a("err"),desig.a("id"),inst.a("tsh"),desig.a("tipo"));
        dependencias(inst.a("mostrarErrores"),desig.a("mostrarErrores"),desig.a("id"),inst.a("tsh"),desig.a("tipo"),desig.a("filaCol"));
        dependencias(inst.a("cod"),desig.a("cod"),desig.a("tipo"),inst.a("tsh"));
        dependencias(inst.a("etq"),desig.a("etq"),desig.a("esDesig"));
        
        calculo(desig.a("tsh"), asignacion);
        calculo(desig.a("etqh"), asignacion);
        
        calculo(inst.a("tipo"), tipoInstIn);
        calculo(inst.a("err"), copiaErroresInstsIn);
        calculo(inst.a("mostrarErrores"), mostrarErroresInstsIn);
        calculo(inst.a("cod"), codInstIn);
        calculo(inst.a("etq"),  etqInstIn);
      
        return inst;
     } 
   
   public TAtributos instOut(Token out, TAtributos exp) {
        regla("Inst -> out (exp) ");
        
        TAtributos inst = atributosPara("INST","tsh","etqh","err","tipo", "cod", "etq","mostrarErrores");
        Atributo filaCol = atributoLexicoPara("STRING","lex",out.getFilaColumna());		
        
        dependencias(exp.a("tsh"),inst.a("tsh"));
        dependencias(exp.a("etqh"),inst.a("etqh"));
        
        dependencias(inst.a("err"),exp.a("err"));
        dependencias(inst.a("mostrarErrores"),exp.a("mostrarErrores"),inst.a("tipo"),filaCol,inst.a("tsh"));
        dependencias(inst.a("tipo"),exp.a("tipo"),inst.a("tsh"));
        dependencias(inst.a("cod"),exp.a("cod"),exp.a("esDesig"),exp.a("tipo"),inst.a("tsh"));
        dependencias(inst.a("etq"),exp.a("etq"),exp.a("esDesig"));
        
        dependencias(exp.a("irvh"),exp.a("etq"),exp.a("esDesig"));
        dependencias(exp.a("irfh"),exp.a("etq"),exp.a("esDesig"));
        
        calculo(exp.a("tsh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        
        calculo(inst.a("tipo"), tipoInstOut);
        calculo(inst.a("err"), copiaErrores);
        calculo(inst.a("mostrarErrores"), mostrarErroresInstsOut);        
        calculo(inst.a("cod"), codInstOut);
        calculo(inst.a("etq"),  sumaEtqOut);
        
        calculo(exp.a("irvh"), sumaEtqDesignador);
        calculo(exp.a("irfh"), sumaEtqDesignador);
        
        return inst;
     } 
   
   public TAtributos instIf(TAtributos exp, TAtributos insts) {
        regla("Inst -> if Exp then Insts endif");
        
        TAtributos inst = atributosPara("INST","tsh","etqh","err","tipo", "cod", "etq","mostrarErrores");
        
        dependencias(exp.a("tsh"),inst.a("tsh"));
        dependencias(exp.a("etqh"),inst.a("etqh"));
        dependencias(insts.a("tsh"),inst.a("tsh"));
        dependencias(insts.a("etqh"),exp.a("etq"), exp.a("esDesig"));
        
        dependencias(inst.a("err"),exp.a("err"),insts.a("err"));
        dependencias(inst.a("mostrarErrores"),exp.a("mostrarErrores"),insts.a("mostrarErrores"));
        dependencias(inst.a("tipo"),exp.a("tipo"),insts.a("tipo"));
        dependencias(inst.a("cod"),exp.a("cod"),insts.a("etq"),insts.a("cod"),exp.a("esDesig"));
        dependencias(inst.a("etq"),insts.a("etq"));
        
        dependencias(exp.a("irvh"),exp.a("etq"), exp.a("esDesig"));
        dependencias(exp.a("irfh"),exp.a("etq"), exp.a("esDesig"));
        
        calculo(exp.a("tsh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        calculo(insts.a("tsh"), asignacion);
        calculo(insts.a("etqh"), sumaEtqDesignadorMas1);
        
        calculo(inst.a("err"), unirDosErrores);
        calculo(inst.a("mostrarErrores"), unirMostrarDosErrores);
        calculo(inst.a("tipo"), unirDosTipos);
        calculo(inst.a("cod"), codInstIf);
        calculo(inst.a("etq"),  asignacion);
        
        calculo(exp.a("irvh"), sumaEtqDesignador);
        calculo(exp.a("irfh"), sumaEtqDesignador);
        
        return inst;
     } 
   
   
   public TAtributos instIfElse(TAtributos exp, TAtributos insts0, TAtributos insts1) {
        regla("Inst -> if Exp then Insts1 else Insts2 endif");
        
        TAtributos inst = atributosPara("INST","tsh","etqh","err","tipo", "cod", "etq","mostrarErrores");
        
        dependencias(exp.a("tsh"),inst.a("tsh"));
        dependencias(insts0.a("tsh"),inst.a("tsh"));
        dependencias(insts1.a("tsh"),inst.a("tsh"));
        dependencias(exp.a("etqh"),inst.a("etqh"));
        dependencias(insts0.a("etqh"),exp.a("etq"),exp.a("esDesig"));
        dependencias(insts1.a("etqh"),insts0.a("etq"));
        
        dependencias(inst.a("err"),exp.a("err"),insts0.a("err"),insts1.a("err"));
        dependencias(inst.a("errorTipo"),exp.a("errorTipo"),insts0.a("errorTipo"),insts1.a("errorTipo"));
        dependencias(inst.a("tipo"),exp.a("tipo"),insts0.a("tipo"),insts1.a("tipo"));
        dependencias(inst.a("cod"),exp.a("cod"),insts0.a("etq"), insts0.a("cod"), insts1.a("etq"), insts1.a("cod"),exp.a("esDesig"));
        dependencias(inst.a("etq"),insts1.a("etq"));
    
        dependencias(exp.a("irvh"),exp.a("etq"), exp.a("esDesig"));
        dependencias(exp.a("irfh"),exp.a("etq"), exp.a("esDesig"));
        
        calculo(exp.a("tsh"), asignacion);
        calculo(insts0.a("tsh"), asignacion);
        calculo(insts1.a("tsh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        calculo(insts0.a("etqh"), sumaEtqDesignadorMas1);
        calculo(insts1.a("etqh"), asignacionSuma1);
        
        calculo(inst.a("err"), unirTresErrores);
        calculo(inst.a("mostrarErrores"), unirMostrarTresErrores);
        calculo(inst.a("tipo"), unirTresTipos);
        calculo(inst.a("cod"), codInstIfElse);
        calculo(inst.a("etq"), asignacion);
        
        calculo(exp.a("irvh"), sumaEtqDesignador);
        calculo(exp.a("irfh"), sumaEtqDesignador);
        
        return inst;
     } 
   
   public TAtributos instWhile(TAtributos exp, TAtributos insts) {
        regla("Inst -> while Exp do Insts endwhile");
        
        TAtributos inst = atributosPara("INST","tsh","etqh","err","tipo", "cod", "etq","mostrarErrores");
        
        dependencias(exp.a("tsh"),inst.a("tsh"));
        dependencias(insts.a("tsh"),inst.a("tsh"));
        dependencias(exp.a("etqh"),inst.a("etqh"));
        dependencias(insts.a("etqh"),exp.a("etq"),exp.a("esDesig"));
              
        dependencias(inst.a("err"),exp.a("err"),insts.a("err"));
        dependencias(inst.a("mostrarErrores"),exp.a("mostrarErrores"),insts.a("mostrarErrores"));
        dependencias(inst.a("tipo"),exp.a("tipo"),insts.a("tipo"));
        dependencias(inst.a("cod"),exp.a("cod"),insts.a("etq"), insts.a("cod"), inst.a("etqh") ,exp.a("esDesig"));
        dependencias(inst.a("etq"),insts.a("etq"));
    
        dependencias(exp.a("irvh"),exp.a("etq"), exp.a("esDesig"));
        dependencias(exp.a("irfh"),exp.a("etq"), exp.a("esDesig"));
        
        calculo(exp.a("tsh"), asignacion);
        calculo(insts.a("tsh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        calculo(insts.a("etqh"), sumaEtqDesignadorMas1);
        
        calculo(inst.a("err"), unirDosErrores);
        calculo(inst.a("mostrarErrores"), unirMostrarDosErrores);
        calculo(inst.a("tipo"), unirDosTipos);
        calculo(inst.a("cod"), codInstWhile);
        calculo(inst.a("etq"), asignacionSuma1);
        
        calculo(exp.a("irvh"), sumaEtqDesignador);
        calculo(exp.a("irfh"), sumaEtqDesignador);
        
        return inst;
     } 
   
   

   public TAtributos instCall(Token iden, TAtributos paramf) {
        regla("Inst = call identificador (ParametrosF) ");
        
        TAtributos inst = atributosPara("INST","tsh","etqh","err","etq","cod","tipo","mostrarErrores");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(paramf.a("tsh"),inst.a("tsh"));
        dependencias(paramf.a("etqh"),inst.a("etqh"));
        dependencias(paramf.a("paramsh"),inst.a("tsh"),identificador);
        
        dependencias(inst.a("err"),paramf.a("err"),inst.a("tsh"),identificador,paramf.a("numParametros"),inst.a("tipo"));     
        dependencias(inst.a("mostrarErrores"),paramf.a("mostrarErrores"),inst.a("tsh"),identificador,paramf.a("numParametros"),filaCol,paramf.a("tipo"));    
        dependencias(inst.a("etq"),paramf.a("etq"));
        dependencias(inst.a("cod"),inst.a("etq"), paramf.a("cod"), identificador, inst.a("tsh"));
        dependencias(inst.a("tipo"),paramf.a("tipo"));
        
        calculo(paramf.a("tsh"),asignacion);
        calculo(paramf.a("etqh"),asignacionSuma5);
        calculo(paramf.a("paramsh"),paramsHeredado);
        calculo(inst.a("err"),copiaErroresCall);
        calculo(inst.a("mostrarErrores"),mostrarErroresInstCall);
        calculo(inst.a("etq"),asignacionSuma1);
        calculo(inst.a("cod"),codCall);

        calculo(inst.a("tipo"),asignacion);
        

        return inst;
     } 
    

   
    
/****************************** PARAMETROSFUNCALL *********************************/     
   
    public TAtributos parametrosFCall0(TAtributos paramfuncall) {
        regla("ParametrosF -> ParametrosFun");
        
        TAtributos parametrosfcall = atributosPara("PARAMETROSFCALL","paramsh","tsh","etqh","etq","cod","err",
                "tipo","numParametros","mostrarErrores");
        
        dependencias(paramfuncall.a("paramsh"),parametrosfcall.a("paramsh"));
        dependencias(paramfuncall.a("tsh"),parametrosfcall.a("tsh"));
        dependencias(paramfuncall.a("etqh"),parametrosfcall.a("etqh"));
        
        dependencias(parametrosfcall.a("etq"),paramfuncall.a("etq"));
        dependencias(parametrosfcall.a("cod"),paramfuncall.a("cod"));
        dependencias(parametrosfcall.a("tipo"),paramfuncall.a("tipo"));
        dependencias(parametrosfcall.a("err"),paramfuncall.a("err"));
        dependencias(parametrosfcall.a("mostrarErrores"),paramfuncall.a("mostrarErrores"));
        dependencias(parametrosfcall.a("numParametros"),paramfuncall.a("numParametros"));
        
        
        calculo(paramfuncall.a("paramsh"),asignacion);
        calculo(paramfuncall.a("tsh"),asignacion);
        calculo(paramfuncall.a("etqh"),asignacionSuma3);
        
        calculo(parametrosfcall.a("err"),copiaErrores);
        calculo(parametrosfcall.a("mostrarErrores"),asignacion);
        calculo(parametrosfcall.a("etq"),asignacionSuma1);
        calculo(parametrosfcall.a("cod"),codigoParametrosFCall0); 
        calculo(parametrosfcall.a("tipo"), asignacion); 
        calculo(parametrosfcall.a("numParametros"), asignacion); 
        
        return parametrosfcall;
     }
    
    public TAtributos parametrosFCall1() {
        regla("ParametrosF -> lambda");
        

        TAtributos parametrosfcall = atributosPara("PARAMETROSFCALL","paramsh","etqh","tsh","tipo","etq","err","cod",
                "numParametros","mostrarErrores");

        dependencias(parametrosfcall.a("etq"),parametrosfcall.a("etqh"));
        
        calculo(parametrosfcall.a("etq"),asignacion);
        calculo(parametrosfcall.a("tipo"),creaTipo);
        calculo(parametrosfcall.a("err"),creaErrores);
        calculo(parametrosfcall.a("cod"),codVacio);
        calculo(parametrosfcall.a("tipo"),creaTipo);
        calculo(parametrosfcall.a("numParametros"),asignacion0);
        calculo(parametrosfcall.a("mostrarErrores"),codMostrarErroresVacio);
        
        return parametrosfcall;
     } 
   

 /****************************** PARAMETROSFUN *********************************/   
     
    public TAtributos parametrosFunCall0(TAtributos paramsfuncall1, TAtributos paramfuncall) {
       regla("ParametrosFunC-> ParametrosFunC , ParametroFunC");
        
        TAtributos paramfuncall0 = atributosPara("PARAMETROSFUNCALL","paramsh","tsh","etqh","etq","err","cod","tipo",
                "numParametros","mostrarErrores");
        
        dependencias(paramsfuncall1.a("paramsh"),paramfuncall0.a("paramsh"));
        dependencias(paramfuncall.a("paramsh"),paramfuncall0.a("paramsh"));
        
        dependencias(paramsfuncall1.a("tsh"),paramfuncall0.a("tsh"));
        dependencias(paramfuncall.a("tsh"),paramfuncall0.a("tsh"));
        
        dependencias(paramsfuncall1.a("etqh"),paramfuncall0.a("etqh"));
        dependencias(paramfuncall.a("etqh"),paramsfuncall1.a("etq"));
        dependencias(paramfuncall0.a("etq"),paramfuncall.a("etq"));
        
        dependencias(paramfuncall0.a("cod"),paramsfuncall1.a("cod"),paramfuncall.a("cod"));
        dependencias(paramfuncall0.a("err"),paramsfuncall1.a("err"),paramfuncall.a("err"));
        dependencias(paramfuncall0.a("mostrarErrores"),paramsfuncall1.a("mostrarErrores"),paramfuncall.a("mostrarErrores"));
        dependencias(paramfuncall0.a("tipo"),paramsfuncall1.a("tipo"),paramfuncall.a("tipo"));
        dependencias(paramfuncall0.a("numParametros"),paramsfuncall1.a("numParametros")); //------------
        
        calculo(paramsfuncall1.a("paramsh"),asignacion);
        calculo(paramfuncall.a("paramsh"),asignacion);
        
        calculo(paramsfuncall1.a("tsh"),asignacion);
        calculo(paramfuncall.a("tsh"),asignacion);
        
        calculo(paramsfuncall1.a("etqh"),asignacion);
        calculo(paramfuncall.a("etqh"),asignacion);
        calculo(paramfuncall0.a("etq"),asignacion);
        calculo(paramfuncall0.a("err"),unirDosErrores);
        calculo(paramfuncall0.a("mostrarErrores"),unirMostrarDosErrores);
        calculo(paramfuncall0.a("cod"),concatenaDosCod);
        calculo(paramfuncall0.a("tipo"),unirDosTipos);
        calculo(paramfuncall0.a("numParametros"),asignacionSuma1);
        return paramfuncall0;
     }   
    
    public TAtributos parametrosFunCall1(TAtributos paramfunc) {
        regla("ParametrosFunC-> ParametroFunC");
        
        TAtributos paramsfuncall = atributosPara("PARAMETROSFUNCALL","paramsh","tsh","err","etqh","cod","etq",
                "tipo","numParametros","mostrarErrores");
        
        dependencias(paramfunc.a("paramsh"),paramsfuncall.a("paramsh"));
        
        dependencias(paramfunc.a("tsh"),paramsfuncall.a("tsh"));
        
        dependencias(paramfunc.a("etqh"),paramsfuncall.a("etqh"));
        dependencias(paramsfuncall.a("cod"),paramfunc.a("cod"),paramfunc.a("err"),paramfunc.a("tipo"));
        dependencias(paramsfuncall.a("etq"),paramfunc.a("etq"));
        dependencias(paramsfuncall.a("err"),paramfunc.a("err"));
        dependencias(paramsfuncall.a("mostrarErrores"),paramfunc.a("mostrarErrores"));
        dependencias(paramsfuncall.a("tipo"),paramfunc.a("tipo"));
        
                
        calculo(paramfunc.a("paramsh"),asignacion);
        calculo(paramfunc.a("tsh"),asignacion);
        calculo(paramfunc.a("etqh"),asignacion);
        
        calculo(paramsfuncall.a("cod"),copiaCodigo);
        calculo(paramsfuncall.a("etq"),asignacion);
        calculo(paramsfuncall.a("tipo"),asignacion);
        calculo(paramsfuncall.a("err"),copiaErrores);
        calculo(paramsfuncall.a("mostrarErrores"),asignacion);
        calculo(paramsfuncall.a("numParametros"),asignacion1);
        
        return paramsfuncall;
     } 
    
  /****************************** PARAMETROFUN *********************************/   
    
    public TAtributos parametroFunCall(Token iden, TAtributos exp) {
       regla("ParametroFunC -> identificador = Exp");
        
        TAtributos paramfuncall = atributosPara("PARAMETROFUNCALL","tsh","etqh","err","cod","etq","tipo","paramsh","mostrarErrores");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(exp.a("tsh"),paramfuncall.a("tsh"));
        dependencias(exp.a("etqh"),paramfuncall.a("etqh"));
        dependencias(paramfuncall.a("err"),exp.a("err"),paramfuncall.a("tsh"),identificador,paramfuncall.a("paramsh"));      
        dependencias(paramfuncall.a("cod"),exp.a("cod"),exp.a("esDesig"),paramfuncall.a("paramsh"),identificador);
        dependencias(paramfuncall.a("etq"),exp.a("etq"),exp.a("esDesig"),paramfuncall.a("paramsh"));       
        dependencias(paramfuncall.a("tipo"),exp.a("tipo"),paramfuncall.a("paramsh"),identificador,paramfuncall.a("tsh"));
        dependencias(paramfuncall.a("mostrarErrores"),exp.a("mostrarErrores"),identificador,paramfuncall.a("paramsh"),exp.a("tipo"), filaCol,paramfuncall.a("tsh"));
        
        calculo(exp.a("tsh"),asignacion);
        calculo(exp.a("etqh"),asignacionSuma1);
        
        calculo(paramfuncall.a("err"),errCall);
        calculo(paramfuncall.a("cod"),codCallId);
        calculo(paramfuncall.a("etq"),etqCall);
        calculo(paramfuncall.a("tipo"),tipoCompatibleCall);
        calculo(paramfuncall.a("mostrarErrores"),mostrarErroresCall);
        
        return paramfuncall;
     } 
    
/****************************** EXP *********************************/   
   
    public TAtributos exp0(TAtributos expnivel10, TAtributos ops0, TAtributos expnivel11) {
        regla("Exp -> ExpNivel10 ops0 ExpNivel11");

        TAtributos exp = atributosPara("EXP","tsh","etqh","tipo","err","cod","etq","esDesig","irvh","irfh","mostrarErrores");
        
        dependencias(expnivel10.a("tsh"),exp.a("tsh"));
	dependencias(expnivel11.a("tsh"),exp.a("tsh"));
	dependencias(expnivel10.a("etqh"),exp.a("etqh"));
	dependencias(expnivel11.a("etqh"),expnivel10.a("etq"));       
        
        dependencias(exp.a("tipo"),ops0.a("op"),expnivel10.a("tipo"),expnivel11.a("tipo"));
        dependencias(exp.a("err"),expnivel10.a("err"),expnivel11.a("err"));
        dependencias(exp.a("mostrarErrores"),expnivel10.a("mostrarErrores"),expnivel11.a("mostrarErrores"),ops0.a("op"),expnivel10.a("tipo"),expnivel11.a("tipo"),ops0.a("filaCol"),exp.a("tsh"));
        dependencias(exp.a("cod"),expnivel10.a("cod"),expnivel11.a("cod"),ops0.a("op"),expnivel10.a("esDesig"),expnivel11.a("esDesig"));
        dependencias(exp.a("etq"),expnivel11.a("etq"),expnivel10.a("esDesig"),expnivel11.a("esDesig"));
       
	dependencias(expnivel10.a("irvh"),expnivel10.a("etq"),expnivel10.a("esDesig"));
        dependencias(expnivel10.a("irfh"),expnivel10.a("etq"),expnivel10.a("esDesig"));
        dependencias(expnivel11.a("irvh"),expnivel11.a("etq"),expnivel11.a("esDesig"));
        dependencias(expnivel11.a("irfh"),expnivel11.a("etq"),expnivel11.a("esDesig"));        
        
        calculo(expnivel10.a("tsh"),asignacion);
	calculo(expnivel11.a("tsh"),asignacion);
	calculo(expnivel10.a("etqh"),asignacion);
	calculo(expnivel11.a("etqh"),asignacion);
        
        calculo(exp.a("tipo"), tipoResultante2);
        calculo(exp.a("err"), unirDosErrores);
        calculo(exp.a("mostrarErrores"), mostrarErroresExp);
        calculo(exp.a("cod"), codExp);
        calculo(exp.a("etq"), sumaEtqExp);     
        calculo(exp.a("esDesig"), asignacionFalseBool);
        
        calculo(expnivel10.a("irvh"),sumaEtqDesignador);
	calculo(expnivel10.a("irfh"),sumaEtqDesignador);
	calculo(expnivel11.a("irvh"),sumaEtqDesignador);
	calculo(expnivel11.a("irfh"),sumaEtqDesignador);
        
        return exp;
     } 
    
    public TAtributos exp1(TAtributos expnivel1) {
        regla("Exp -> ExpNivel1");

        TAtributos exp = atributosPara("EXP","tsh","etqh","tipo","err","cod","etq","esDesig","irvh","irfh","mostrarErrores");

        dependencias(expnivel1.a("irfh"),exp.a("irfh"));
	dependencias(expnivel1.a("irvh"),exp.a("irvh"));        
        dependencias(expnivel1.a("etqh"),exp.a("etqh"));
	dependencias(expnivel1.a("tsh"),exp.a("tsh"));
                  
        dependencias(exp.a("tipo"),expnivel1.a("tipo"));
        dependencias(exp.a("err"),expnivel1.a("err"));
        dependencias(exp.a("mostrarErrores"),expnivel1.a("mostrarErrores"));
        dependencias(exp.a("cod"),expnivel1.a("cod"),exp.a("err"),exp.a("tipo"));
        dependencias(exp.a("etq"),expnivel1.a("etq"));
        dependencias(exp.a("esDesig"),expnivel1.a("esDesig"));
	
        calculo(expnivel1.a("tsh"),asignacion);
	calculo(expnivel1.a("etqh"),asignacion);
        
        calculo(exp.a("tipo"), asignacion);
        calculo(exp.a("err"), copiaErrores);
        calculo(exp.a("mostrarErrores"), asignacion);
        calculo(exp.a("cod"), copiaCodigo);
        calculo(exp.a("etq"), asignacion);
        calculo(exp.a("esDesig"), asignacion);
        
        calculo(expnivel1.a("irvh"), asignacion);
        calculo(expnivel1.a("irfh"), asignacion);       
        
        return exp;
     } 

/****************************** OPS0 *********************************/   
 
    public TAtributos ops0Men(Token op) {
        regla("Ops0 -> <");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodMen);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;
     } 
    
    public TAtributos ops0May(Token op) {
        regla("Ops0 -> >");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodMay);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;        
     } 
    
    public TAtributos ops0MenIgual(Token op) {
        regla("Ops0 -> <=");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodMenIgual);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;
     } 
    
    public TAtributos ops0MayIgual(Token op) {
        regla("Ops0 -> >=");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodMayIgual);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;
     } 
    
    public TAtributos ops0Igual(Token op) {
        regla("Ops0 -> ==");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodIgual);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;
     } 
    
    public TAtributos ops0NoIgual(Token op) {
        regla("Ops0 -> !=");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops0 = atributosPara("OPS0", "op","filaCol");
        
        dependencias(ops0.a("filaCol"), filaCol);
        
        calculo(ops0.a("op"), creaCodNoIgual);
        calculo(ops0.a("filaCol"), asignacion);
        
        return ops0;
     } 

/****************************** EXPNIVEL1 *********************************/   
 
   public TAtributos expnivel10(TAtributos expnivel11, TAtributos ops1, TAtributos expnivel2) {
        regla("ExpNivel1 -> ExpNivel1 ops1 ExpNivel2");
        
        TAtributos expnivel10 = atributosPara("EXPNIVEL1","etqh","tsh","tipo","err","cod","etq","esDesig","irvh","irfh","mostrarErrores");
        
        dependencias(expnivel11.a("tsh"),expnivel10.a("tsh"));
	dependencias(expnivel2.a("tsh"),expnivel10.a("tsh"));
	dependencias(expnivel11.a("etqh"),expnivel10.a("etqh"));
	dependencias(expnivel2.a("etqh"),expnivel11.a("etq"),ops1.a("op"));
        
        dependencias(expnivel10.a("tipo"),ops1.a("op"),expnivel11.a("tipo"),expnivel2.a("tipo"));
        dependencias(expnivel10.a("err"),expnivel11.a("err"),expnivel2.a("err"));
        dependencias(expnivel10.a("mostrarErrores"),expnivel11.a("mostrarErrores"),expnivel2.a("mostrarErrores"),ops1.a("op"),expnivel11.a("tipo"),expnivel2.a("tipo"),ops1.a("filaCol"),expnivel10.a("tsh"));
        dependencias(expnivel10.a("cod"),expnivel11.a("cod"),expnivel10.a("irvh"),expnivel2.a("cod"),expnivel11.a("esDesig"),expnivel2.a("esDesig"),ops1.a("op"),expnivel10.a("tipo"));
        dependencias(expnivel10.a("etq"),expnivel2.a("etq"),expnivel11.a("esDesig"),expnivel2.a("esDesig"),ops1.a("op"));
        
        dependencias(expnivel11.a("irvh"),ops1.a("op"),expnivel10.a("irvh"),expnivel11.a("etq"),expnivel11.a("esDesig"));
        dependencias(expnivel11.a("irfh"),ops1.a("op"),expnivel11.a("etq"),expnivel11.a("esDesig"));
        dependencias(expnivel2.a("irvh"), ops1.a("op"),expnivel10.a("irvh"),expnivel2.a("etq"),expnivel2.a("esDesig"));
        dependencias(expnivel2.a("irfh"), ops1.a("op"),expnivel11.a("irfh"),expnivel2.a("etq"),expnivel2.a("esDesig"));
        
        calculo(expnivel11.a("tsh"),asignacion);
	calculo(expnivel2.a("tsh"),asignacion);
	calculo(expnivel11.a("etqh"), asignacion);
        calculo(expnivel2.a("etqh"), etqhSuma3);
                
        calculo(expnivel10.a("tipo"), tipoResultante2);
        calculo(expnivel10.a("err"), unirDosErrores);
        calculo(expnivel10.a("mostrarErrores"), mostrarErroresExpNivel1);
        calculo(expnivel10.a("cod"), codExpnivel1);
        calculo(expnivel10.a("etq"), etqExpnivel1); 
        calculo(expnivel10.a("esDesig"), asignacionFalseBool);

        calculo(expnivel11.a("irvh"),irf_irv_Op);
	calculo(expnivel11.a("irfh"),irf_irv_OpSuma2);
	calculo(expnivel2.a("irvh"),irf_irv_Op);
	calculo(expnivel2.a("irfh"),irf_irv_Op);
        
        return expnivel10;
     } 
   
   
    public TAtributos expnivel11(TAtributos expnivel2) {
        regla("ExpNivel1 -> ExpNivel2");
        
        TAtributos expnivel1 = atributosPara("EXPNIVEL1","irfh","irvh","tipo","err","cod","etq","tsh","etqh","esDesig","mostrarErrores");
        
        dependencias(expnivel2.a("tsh"),expnivel1.a("tsh"));
	dependencias(expnivel2.a("etqh"),expnivel1.a("etqh"));
        
        dependencias(expnivel2.a("irvh"),expnivel1.a("irvh"));
	dependencias(expnivel2.a("irfh"),expnivel1.a("irfh"));
        
        dependencias(expnivel1.a("tipo"),expnivel2.a("tipo"));
        dependencias(expnivel1.a("err"),expnivel2.a("err"));
        dependencias(expnivel1.a("mostrarErrores"),expnivel2.a("mostrarErrores"));
        dependencias(expnivel1.a("cod"),expnivel2.a("cod"),expnivel1.a("err"),expnivel1.a("tipo"));
        dependencias(expnivel1.a("etq"),expnivel2.a("etq"));
        dependencias(expnivel1.a("esDesig"),expnivel2.a("esDesig"));
        
        calculo(expnivel2.a("tsh"), asignacion);
        calculo(expnivel2.a("etqh"), asignacion);
        
        calculo(expnivel1.a("tipo"), asignacion);
        calculo(expnivel1.a("err"), copiaErrores);
        calculo(expnivel1.a("mostrarErrores"), asignacion);
        calculo(expnivel1.a("cod"), copiaCodigo);
        calculo(expnivel1.a("etq"), asignacion);
        calculo(expnivel1.a("esDesig"), asignacion);
        
        calculo(expnivel2.a("irvh"), asignacion);
        calculo(expnivel2.a("irfh"), asignacion);

        return expnivel1;
     }  
    
    
/****************************** OPS1 *********************************/   
     
    public TAtributos ops1Mas(Token op) {
        regla("Ops1 -> +");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops1 = atributosPara("OPS1", "op","filaCol");
        
        dependencias(ops1.a("filaCol"), filaCol);
        
        calculo(ops1.a("op"), creaCodMas);
        calculo(ops1.a("filaCol"), asignacion);
        
        return ops1;
     } 
    
    public TAtributos ops1Menos(Token op) {
        regla("Ops1 -> -");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops1 = atributosPara("OPS1", "op","filaCol");
        
        dependencias(ops1.a("filaCol"), filaCol);
        
        calculo(ops1.a("op"), creaCodMenos);
        calculo(ops1.a("filaCol"), asignacion);
        
        return ops1;        
     } 
    
    public TAtributos ops1Or(Token op) {
        regla("ops1 -> or");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops1 = atributosPara("OPS1", "op","filaCol");
        
        dependencias(ops1.a("filaCol"), filaCol);
        
        calculo(ops1.a("op"), creaCodOr);
        calculo(ops1.a("filaCol"), asignacion);
        
        return ops1;
     } 
    
/****************************** EXPNIVEL2 *********************************/   
 
   public TAtributos expnivel20(TAtributos expnivel21, TAtributos ops2, TAtributos expnivel3) {
        regla("ExpNivel2 -> ExpNivel2 ops2 ExpNivel3");
              
        TAtributos expnivel20 = atributosPara("EXPNIVEL2","tsh","etqh","irvh","irfh","tipo","err","cod","etq","esDesig","mostrarErrores");
               
        dependencias(expnivel21.a("tsh"),expnivel20.a("tsh"));
	dependencias(expnivel3.a("tsh"),expnivel20.a("tsh"));
	dependencias(expnivel21.a("etqh"),expnivel20.a("etqh"));
	dependencias(expnivel3.a("etqh"),expnivel21.a("etq"), ops2.a("op"));
        
        dependencias(expnivel20.a("tipo"),ops2.a("op"),expnivel21.a("tipo"),expnivel3.a("tipo"));
        dependencias(expnivel20.a("err"),expnivel21.a("err"),expnivel3.a("err"));
        dependencias(expnivel20.a("mostrarErrores"),expnivel21.a("mostrarErrores"),expnivel3.a("mostrarErrores"),ops2.a("op"),expnivel21.a("tipo"),expnivel3.a("tipo"),ops2.a("filaCol"),expnivel20.a("tsh"));
                                                                                                    
        dependencias(expnivel20.a("cod"),ops2.a("op"),expnivel21.a("cod"),expnivel20.a("irfh"),expnivel3.a("cod"),expnivel21.a("esDesig"),expnivel3.a("esDesig"),expnivel20.a("tipo"));
        dependencias(expnivel20.a("etq"),ops2.a("op"),expnivel3.a("etq"),expnivel21.a("esDesig"),expnivel3.a("esDesig"));
       
	dependencias(expnivel21.a("irvh"),ops2.a("op"),expnivel21.a("etq"),expnivel21.a("esDesig"));
        dependencias(expnivel21.a("irfh"),ops2.a("op"),expnivel20.a("irfh"),expnivel21.a("etq"),expnivel21.a("esDesig"));	
	dependencias(expnivel3.a("irvh"),ops2.a("op"),expnivel20.a("irvh"),expnivel3.a("etq"),expnivel3.a("esDesig"));
        dependencias(expnivel3.a("irfh"),ops2.a("op"),expnivel20.a("irfh"),expnivel3.a("etq"),expnivel3.a("esDesig"));
        
	calculo(expnivel21.a("tsh"),asignacion);
	calculo(expnivel3.a("tsh"),asignacion);
	calculo(expnivel21.a("etqh"),asignacion);
	calculo(expnivel3.a("etqh"),etqhSuma3Expnivel2);
                
        calculo(expnivel20.a("esDesig"),asignacionFalseBool);	
        calculo(expnivel20.a("tipo"), tipoResultante2);
        calculo(expnivel20.a("err"), unirDosErrores);
        calculo(expnivel20.a("mostrarErrores"), mostrarErroresExpNivel2);
        calculo(expnivel20.a("cod"), codExpnivel2);
        calculo(expnivel20.a("etq"), etqExpnivel2);
       
        calculo(expnivel21.a("irvh"),irf_irv_OpAndSuma2);
        calculo(expnivel21.a("irfh"),irf_irv_OpAnd);
        calculo(expnivel3.a("irvh"), irf_irv_OpAnd);
        calculo(expnivel3.a("irfh"), irf_irv_OpAnd);
	
        return expnivel20;
     } 
   
    public TAtributos expnivel21(TAtributos expnivel3) {
         regla("ExpNivel2 -> ExpNivel3");
         
        TAtributos expnivel2 = atributosPara("EXPNIVEL2","tsh","etqh","irvh","irfh","tipo","err","cod","etq","esDesig","mostrarErrores");
        
        dependencias(expnivel3.a("tsh"),expnivel2.a("tsh"));
	dependencias(expnivel3.a("etqh"),expnivel2.a("etqh"));
        
        dependencias(expnivel2.a("tipo"),expnivel3.a("tipo"));
        dependencias(expnivel2.a("err"),expnivel3.a("err"));
        dependencias(expnivel2.a("mostrarErrores"),expnivel3.a("mostrarErrores"));
        dependencias(expnivel2.a("cod"),expnivel3.a("cod"),expnivel2.a("err"),expnivel2.a("tipo"));
        dependencias(expnivel2.a("etq"),expnivel3.a("etq"));
        dependencias(expnivel2.a("esDesig"),expnivel3.a("esDesig"));
        
        dependencias(expnivel3.a("irvh"),expnivel2.a("irvh"));
        dependencias(expnivel3.a("irfh"),expnivel2.a("irfh"));
        
        calculo(expnivel3.a("tsh"),asignacion);
	calculo(expnivel3.a("etqh"),asignacion);
        
        calculo(expnivel2.a("tipo"), asignacion);
        calculo(expnivel2.a("err"), copiaErrores);
        calculo(expnivel2.a("mostrarErrores"), asignacion);
        calculo(expnivel2.a("cod"), copiaCodigo);
        calculo(expnivel2.a("etq"), asignacion);
        calculo(expnivel2.a("esDesig"),asignacion);        
        
        calculo(expnivel3.a("irvh"), asignacion);
        calculo(expnivel3.a("irfh"),asignacion);
        
        return expnivel2;
     }  

/****************************** OPS2 *********************************/   
    
 
    
     public TAtributos ops2Mul(Token op) {
        regla("Ops2 -> *");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops2 = atributosPara("OPS2", "op","filaCol");
        
        dependencias(ops2.a("filaCol"), filaCol);
        
        calculo(ops2.a("filaCol"), asignacion);
        calculo(ops2.a("op"), creaCodMul);
        
        return ops2;
     } 
    
    public TAtributos ops2Div(Token op) {
        regla("Ops2 -> /");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops2 = atributosPara("OPS2", "op","filaCol");
        
        dependencias(ops2.a("filaCol"), filaCol);
        
        calculo(ops2.a("filaCol"), asignacion);
        calculo(ops2.a("op"), creaCodDiv);
        
        return ops2;        
     } 
    
    public TAtributos ops2Mod(Token op) {
        regla("Ops2 -> %");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops2 = atributosPara("OPS2", "op","filaCol");
        
        dependencias(ops2.a("filaCol"), filaCol);
        
        calculo(ops2.a("filaCol"), asignacion);
        calculo(ops2.a("op"), creaCodMod);
        
        return ops2;
     } 
    
    public TAtributos ops2And(Token op) {
        regla("Ops2 -> and");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops2 = atributosPara("OPS2", "op","filaCol");
        
        dependencias(ops2.a("filaCol"), filaCol);
        
        calculo(ops2.a("filaCol"), asignacion);
        calculo(ops2.a("op"), creaCodAnd);
        
        return ops2;
     } 
    
/****************************** EXPNIVEL3 *********************************/   
 
    public TAtributos expnivel30(TAtributos expnivel4, TAtributos ops3, TAtributos expnivel31) {
         regla("ExpNivel3 -> ExpNivel4 ops3 ExpNivel3");
        
        TAtributos expnivel30 = atributosPara("EXPNIVEL3","etqh","tsh","tipo","err","cod","etq","esDesig","irvh","irfh","mostrarErrores");
		
	dependencias(expnivel4.a("tsh"),expnivel30.a("tsh"));
	dependencias(expnivel31.a("tsh"),expnivel30.a("tsh"));
	dependencias(expnivel4.a("etqh"),expnivel30.a("etqh"));
	dependencias(expnivel31.a("etqh"),expnivel4.a("etq"));
        
        dependencias(expnivel30.a("tipo"),ops3.a("op"),expnivel31.a("tipo"),expnivel4.a("tipo"));
        dependencias(expnivel30.a("err"),expnivel31.a("err"),expnivel4.a("err"));
        dependencias(expnivel30.a("mostrarErrores"),expnivel31.a("mostrarErrores"),expnivel4.a("mostrarErrores"),ops3.a("op"),expnivel31.a("tipo"),expnivel4.a("tipo"),ops3.a("filaCol"),expnivel30.a("tsh"));
        dependencias(expnivel30.a("cod"),expnivel4.a("cod"),expnivel31.a("cod"),ops3.a("op"),expnivel4.a("esDesig"),expnivel31.a("esDesig"));
        dependencias(expnivel30.a("etq"),expnivel31.a("etq"),expnivel4.a("esDesig"),expnivel31.a("esDesig"));
        
        dependencias(expnivel4.a("irvh"),expnivel4.a("etq"),expnivel4.a("esDesig"));
	dependencias(expnivel4.a("irfh"),expnivel4.a("etq"),expnivel4.a("esDesig"));
	dependencias(expnivel31.a("irvh"),expnivel31.a("etq"),expnivel31.a("esDesig"));
	dependencias(expnivel31.a("irfh"),expnivel31.a("etq"),expnivel31.a("esDesig"));        
        
        calculo(expnivel4.a("tsh"),asignacion);
	calculo(expnivel31.a("tsh"),asignacion);
	calculo(expnivel4.a("etqh"),asignacion);
	calculo(expnivel31.a("etqh"),asignacion);        
        
        calculo(expnivel30.a("tipo"), tipoResultante2);
        calculo(expnivel30.a("err"), unirDosErrores);
        calculo(expnivel30.a("mostrarErrores"), mostrarErroresExpNivel3);
        calculo(expnivel30.a("cod"), codExp);
        calculo(expnivel30.a("etq"), sumaEtqExp);        
        calculo(expnivel30.a("esDesig"),asignacionFalseBool);
        
	calculo(expnivel4.a("irvh"),sumaEtqDesignador);
	calculo(expnivel4.a("irfh"),sumaEtqDesignador);
	calculo(expnivel31.a("irvh"),sumaEtqDesignador);
	calculo(expnivel31.a("irfh"),sumaEtqDesignador);	
	
        return expnivel30;
     } 
    
    public TAtributos expnivel31(TAtributos expnivel4) {
        regla("ExpNivel3 -> ExpNivel4");
        
        TAtributos expnivel3 = atributosPara("EXPNIVEL3","tsh","etqh","irvh","irfh","tipo","err","cod","etq","esDesig","mostrarErrores");
		
	dependencias(expnivel4.a("tsh"),expnivel3.a("tsh"));
	dependencias(expnivel4.a("etqh"),expnivel3.a("etqh"));
        
        dependencias(expnivel3.a("tipo"),expnivel4.a("tipo"));
        dependencias(expnivel3.a("err"),expnivel4.a("err"));
        dependencias(expnivel3.a("mostrarErrores"),expnivel4.a("mostrarErrores"));
        dependencias(expnivel3.a("cod"),expnivel4.a("cod"),expnivel3.a("err"),expnivel3.a("tipo"));
        dependencias(expnivel3.a("etq"),expnivel4.a("etq"));
        dependencias(expnivel3.a("esDesig"),expnivel4.a("esDesig"));
        
        dependencias(expnivel4.a("irvh"),expnivel3.a("irvh"));
        dependencias(expnivel4.a("irfh"),expnivel3.a("irfh"));
		
	calculo(expnivel4.a("tsh"),asignacion);
	calculo(expnivel4.a("etqh"),asignacion);
        
        calculo(expnivel3.a("tipo"), asignacion);
        calculo(expnivel3.a("err"), copiaErrores);
        calculo(expnivel3.a("mostrarErrores"), asignacion);
        calculo(expnivel3.a("cod"), copiaCodigo);
        calculo(expnivel3.a("etq"), asignacion);
        calculo(expnivel3.a("esDesig"),asignacion);
        
        calculo(expnivel4.a("irvh"), asignacion);
        calculo(expnivel4.a("irfh"),asignacion);

        return expnivel3;
     }  
    
/****************************** OPS3 *********************************/   
    
    public TAtributos ops3DespDer(Token op) {
        regla("Ops3 -> >>");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops3 = atributosPara("OPS3", "op","filaCol");
        
        dependencias(ops3.a("filaCol"), filaCol);
        
        calculo(ops3.a("filaCol"), asignacion);        
        calculo(ops3.a("op"), creaCodDespDer);
        
        return ops3;
     } 
    
    public TAtributos ops3DespIzq(Token op) {
        regla("Ops3 -> <<");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops3 = atributosPara("OPS3", "op","filaCol");
        
        dependencias(ops3.a("filaCol"), filaCol);
        
        calculo(ops3.a("filaCol"), asignacion); 
        calculo(ops3.a("op"), creaCodDespIzq);
        
        return ops3;        
     } 
     
/****************************** EXPNIVEL4 *********************************/   
    
    public TAtributos expnivel40(TAtributos ops4, TAtributos expnivel5) {
           regla("ExpNivel4 -> Ops4 expnivel5");
        
        TAtributos expnivel4 = atributosPara("EXPNIVEL4","etqh","tsh","irvh","irfh","tipo","err","cod","etq","esDesig","mostrarErrores");
		
	dependencias(expnivel5.a("tsh"),expnivel4.a("tsh"));
        dependencias(expnivel5.a("etqh"),expnivel4.a("etqh"));
        
        dependencias(expnivel4.a("tipo"),ops4.a("op"),expnivel5.a("tipo"));
        dependencias(expnivel4.a("err"),expnivel5.a("err"));
        dependencias(expnivel4.a("mostrarErrores"),expnivel5.a("mostrarErrores"),ops4.a("op"),expnivel5.a("tipo"),ops4.a("filaCol"),expnivel4.a("tsh"));
        dependencias(expnivel4.a("cod"),expnivel5.a("cod"),ops4.a("op"),expnivel5.a("esDesig"),expnivel4.a("tipo"));
        dependencias(expnivel4.a("etq"),expnivel5.a("etq"),expnivel5.a("esDesig"));      
                
        dependencias(expnivel5.a("irvh"),expnivel4.a("irvh"));
        dependencias(expnivel5.a("irfh"),expnivel4.a("irfh"));
        
        calculo(expnivel5.a("tsh"), asignacion);
        calculo(expnivel5.a("etqh"), asignacion);
        
        calculo(expnivel4.a("tipo"),tipoResultante1);
        calculo(expnivel4.a("err"), copiaErrores);
        calculo(expnivel4.a("mostrarErrores"), mostrarErroresExpNivel4);
        calculo(expnivel4.a("cod"), codExpnivel4);
        calculo(expnivel4.a("etq"), sumaEtqDesignadorMas1);
        calculo(expnivel4.a("esDesig"),asignacionFalseBool);
        
        calculo(expnivel5.a("irvh"), asignacion);
        calculo(expnivel5.a("irfh"), asignacion);
        
        return expnivel4;
    }
    
    public TAtributos expnivel41(TAtributos exp) {
        regla("ExpNivel4 -> ( Exp ) ");
        
        TAtributos expnivel4 = atributosPara("EXPNIVEL4","irvh","irfh","tsh","etqh","tipo","err","cod","etq","esDesig","mostrarErrores");		
	
	dependencias(exp.a("tsh"),expnivel4.a("tsh"));
        dependencias(exp.a("etqh"),expnivel4.a("etqh"));
        
        dependencias(expnivel4.a("tipo"),exp.a("tipo"));
        dependencias(expnivel4.a("err"),exp.a("err"));
        dependencias(expnivel4.a("mostrarErrores"),exp.a("mostrarErrores"));
        dependencias(expnivel4.a("cod"),exp.a("cod"),expnivel4.a("err"),expnivel4.a("tipo"));
        dependencias(expnivel4.a("etq"),exp.a("etq"));
        dependencias(expnivel4.a("esDesig"),exp.a("esDesig"));
        
        dependencias(exp.a("irvh"),expnivel4.a("irvh"));
        dependencias(exp.a("irfh"),expnivel4.a("irfh"));
        
	calculo(exp.a("tsh"),asignacion);
        calculo(exp.a("etqh"),asignacion);
        
        calculo(expnivel4.a("tipo"), asignacion);
        calculo(expnivel4.a("err"), copiaErrores);
        calculo(expnivel4.a("mostrarErrores"), asignacion);
        calculo(expnivel4.a("cod"), copiaCodigo);
        calculo(expnivel4.a("etq"), asignacion);
        calculo(expnivel4.a("esDesig"),asignacion);
        
        calculo(exp.a("irvh"),asignacion);
        calculo(exp.a("irfh"),asignacion);
        
        return expnivel4;                
     } 
    
    public TAtributos expnivel43(TAtributos expnivel5) {
       regla("ExpNivel4 -> ExpNivel5 ");
        
        TAtributos expnivel4 = atributosPara("EXPNIVEL4","irvh","irfh","tsh","etqh","tipo","err","cod","etq","esDesig","mostrarErrores");
		
	dependencias(expnivel5.a("tsh"),expnivel4.a("tsh"));
        dependencias(expnivel5.a("etqh"),expnivel4.a("etqh"));
        
        dependencias(expnivel4.a("tipo"),expnivel5.a("tipo"));
        dependencias(expnivel4.a("err"),expnivel5.a("err"));
        dependencias(expnivel4.a("mostrarErrores"),expnivel5.a("mostrarErrores"));
        dependencias(expnivel4.a("cod"),expnivel5.a("cod"),expnivel4.a("err"),expnivel4.a("tipo"));
        dependencias(expnivel4.a("etq"),expnivel5.a("etq"));
        dependencias(expnivel4.a("esDesig"),expnivel5.a("esDesig"));        
                
        dependencias(expnivel5.a("irvh"),expnivel4.a("irvh"));
        dependencias(expnivel5.a("irfh"),expnivel4.a("irfh"));
        
        calculo(expnivel5.a("tsh"),asignacion);
        calculo(expnivel5.a("etqh"),asignacion);
        
        calculo(expnivel4.a("err"), copiaErrores);
        calculo(expnivel4.a("mostrarErrores"), asignacion);
        calculo(expnivel4.a("tipo"), asignacion);
        calculo(expnivel4.a("cod"), copiaCodigo);
        calculo(expnivel4.a("etq"), asignacion);
        calculo(expnivel4.a("esDesig"),asignacion);
        
        calculo(expnivel5.a("irfh"),asignacion);
        calculo(expnivel5.a("irvh"),asignacion);
        
        return expnivel4;               
     } 
        
  /****************************** EXP NIVEL 1 *********************************/   
   
   public TAtributos expnivel5Natural(Token vnatural) {
       regla("expnivel5 -> VNATURAL");
         
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","irvh","irfh","etqh","err","tsh","tipo","cod","etq","esDesig","mostrarErrores");
		
	Atributo astring = atributoLexicoPara("STRING","lex",vnatural.lex());	
	
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
	dependencias(expnivel5.a("cod"),astring);        
        
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(expnivel5.a("tipo"), creaNatural);
        calculo(expnivel5.a("cod"), codApilaValor);
	calculo(expnivel5.a("etq"), asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool); 
        
        return expnivel5;
    }  
   
   public TAtributos expnivel5Integer(Token vinteger) {
          regla("expnivel5 -> VINTEGER");
         
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","err","irvh","irfh","etqh","tsh","tipo","cod","etq","esDesig","mostrarErrores");
		
	Atributo astring = atributoLexicoPara("STRING","lex",vinteger.lex());	
	
        
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
	dependencias(expnivel5.a("cod"),astring);
        
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(expnivel5.a("tipo"), creaInt);
        calculo(expnivel5.a("cod"), codApilaValor);
	calculo(expnivel5.a("etq"),asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool); 
        
        return expnivel5;
    }  
   
   public TAtributos expnivel5Character(Token vchar) {
           regla("expnivel5 -> VCHAR");
         
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","err","irvh","irfh","etqh","tsh","tipo","cod","etq","esDesig","mostrarErrores");
		
	Atributo astring = atributoLexicoPara("STRING","lex",vchar.lex());	
	
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
	dependencias(expnivel5.a("cod"),astring);
        
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("tipo"), creaChar);
        calculo(expnivel5.a("cod"), codApilaCharacter);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
	calculo(expnivel5.a("etq"),asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool); 
        
        return expnivel5;
    }  
   
   public TAtributos expnivel5Float(Token vfloat) {
           regla("expnivel5 -> VFLOAT");
         
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","err","etqh","tsh","irvh","irfh","tipo","cod","etq","esDesig","mostrarErrores");
		
	Atributo astring = atributoLexicoPara("STRING","lex",vfloat.lex());	
	
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
	dependencias(expnivel5.a("cod"),astring);
        
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(expnivel5.a("tipo"), creaFloat);
        calculo(expnivel5.a("cod"), codApilaValor);
	calculo(expnivel5.a("etq"),asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool);
        
        return expnivel5;
    }  
   
   public TAtributos expnivel5BooleanTrue() {
          regla("expnivel5 -> TRUE");
         
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","err","irvh","irfh","etqh","tsh","tipo","cod","etq","esDesig","mostrarErrores");
		
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
	
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("tipo"), creaBool);
        calculo(expnivel5.a("cod"), codApilatrue);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
	calculo(expnivel5.a("etq"),asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool); 
        
        return expnivel5;
    } 
   
   public TAtributos expnivel5BooleanFalse() {
        regla("expnivel5 -> FALSE");
        
        TAtributos expnivel5 = atributosPara("EXPNIVEL5","err","irvh","irfh","etqh","tsh","tipo","cod","etq","esDesig","mostrarErrores");
	
        dependencias(expnivel5.a("etq"),expnivel5.a("etqh"));
        
        calculo(expnivel5.a("err"), creaErrores);
        calculo(expnivel5.a("mostrarErrores"), codMostrarErroresVacio);
        calculo(expnivel5.a("tipo"), creaBool);
        calculo(expnivel5.a("cod"), codApilafalse);
	calculo(expnivel5.a("etq"),asignacionSuma1);
	calculo(expnivel5.a("esDesig"),asignacionFalseBool); 
        
        return expnivel5;
    } 
   
    public TAtributos expnivel5Desig(TAtributos desig) {
        regla("expnivel5 -> Designador");
       TAtributos expnivel5 = atributosPara("EXPNIVEL5","irvh","irfh","etqh","tsh","tipo","err","cod","etq","esDesig","mostrarErrores");
		
	dependencias(desig.a("etqh"),expnivel5.a("etqh"));
        dependencias(desig.a("tsh"),expnivel5.a("tsh"));
        
        dependencias(expnivel5.a("tipo"),desig.a("tipo"));
        dependencias(expnivel5.a("err"),desig.a("err"));
        dependencias(expnivel5.a("mostrarErrores"),desig.a("mostrarErrores"));
        dependencias(expnivel5.a("cod"),desig.a("cod"),expnivel5.a("err"),expnivel5.a("tipo"));
        dependencias(expnivel5.a("etq"),desig.a("etq"));
        dependencias(expnivel5.a("esDesig"),desig.a("esDesig"));
        
        dependencias(desig.a("irvh"),expnivel5.a("irvh"));
        dependencias(desig.a("irfh"),expnivel5.a("irfh"));        
        
        calculo(desig.a("tsh"),asignacion);
        calculo(desig.a("etqh"),asignacion);
        calculo(desig.a("irvh"),asignacion);
        calculo(desig.a("irfh"),asignacion);
        
        calculo(expnivel5.a("tipo"), asignacion);
        calculo(expnivel5.a("err"), copiaErrores);
        calculo(expnivel5.a("mostrarErrores"), asignacion);
        calculo(expnivel5.a("cod"), copiaCodigo);
        calculo(expnivel5.a("etq"), asignacion);
        calculo(expnivel5.a("esDesig"),asignacion);		
		        
        return expnivel5;
    }
    
    /****************************** DESIGNADOR *********************************/
    
     public TAtributos designadorIden(Token iden) {
        regla("Designador -> Identificador ");
        
        TAtributos designadorId = atributosPara("DESIGNADOR","irvh","irfh","tsh","etqh","tipo","err","id","cod","etq","esDesig","mostrarErrores","filaCol");
        Atributo identificador = atributoLexicoPara("IDENTIFICADOR","lex",iden.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",iden.getFilaColumna());
        
        dependencias(designadorId.a("tipo"), identificador, designadorId.a("tsh"));
        dependencias(designadorId.a("err"), identificador,designadorId.a("tsh"));
        dependencias(designadorId.a("mostrarErrores"), identificador,designadorId.a("tsh"),filaCol);
        dependencias(designadorId.a("id"), identificador);
        dependencias(designadorId.a("filaCol"), filaCol);
        dependencias(designadorId.a("cod"), identificador,designadorId.a("tsh"));
        dependencias(designadorId.a("etq"), designadorId.a("etqh"),identificador,designadorId.a("tsh"));
        
        calculo(designadorId.a("tipo"),dameTipoDeIdConTS);
        calculo(designadorId.a("err"), creaErroresDesigIden);
        calculo(designadorId.a("mostrarErrores"), mostrarErroresDesigIden);
        calculo(designadorId.a("id"), asignacion);
        calculo(designadorId.a("filaCol"), asignacion);
        calculo(designadorId.a("cod"), codDesigIden);
        calculo(designadorId.a("etq"), etqDesigIden);
        calculo(designadorId.a("esDesig"), asignacionTrueBool);
        
       
        return designadorId;
    }   
     
      public TAtributos designadorArray(TAtributos desig1, TAtributos exp) {
        regla("Designador -> Designador [Exp]");
        
        TAtributos desig0 = atributosPara("DESIGNADOR","tsh","etqh","irvh","irfh","id","err","tipo","cod","etq","esDesig","mostrarErrores","filaCol");
        
        dependencias(desig1.a("tsh"), desig0.a("tsh"));
        dependencias(desig1.a("etqh"), desig0.a("etqh"));
        dependencias(exp.a("tsh"), desig0.a("tsh"));
        dependencias(exp.a("etqh"), desig1.a("etq"));
        
        dependencias(desig0.a("tipo"), desig1.a("tipo"),exp.a("tipo"),desig0.a("tsh"));
        dependencias(desig0.a("cod"), desig1.a("cod"),exp.a("cod"),desig1.a("tipo"),desig0.a("tsh"),exp.a("esDesig"));
        dependencias(desig0.a("etq"), exp.a("etq"),exp.a("esDesig"));
        dependencias(desig0.a("id"), desig1.a("id"));
        dependencias(desig0.a("filaCol"), desig1.a("filaCol"));
        dependencias(desig0.a("err"), desig1.a("err"),exp.a("err"));
        dependencias(desig0.a("mostrarErrores"), desig1.a("mostrarErrores"),exp.a("mostrarErrores"),desig1.a("tipo"),exp.a("tipo"),desig0.a("tsh"),desig0.a("id"),desig0.a("filaCol"));
         
        dependencias(desig1.a("irvh"), desig0.a("irvh"));
        dependencias(desig1.a("irfh"), desig0.a("irfh"));
        dependencias(exp.a("irvh"), desig0.a("irvh"));
        dependencias(exp.a("irfh"), desig0.a("irfh"));       
        
        calculo(desig1.a("tsh"), asignacion);
        calculo(desig1.a("etqh"), asignacion);
        calculo(exp.a("tsh"), asignacion);
        calculo(exp.a("etqh"), asignacion);
        
        calculo(desig0.a("id"), asignacion);
        calculo(desig0.a("filaCol"), asignacion);
        calculo(desig0.a("err"), unirDosErrores);
        calculo(desig0.a("mostrarErrores"), mostrarErroresDesignadorArray);
        calculo(desig0.a("tipo"), tipoDesignadorIndex);
        calculo(desig0.a("cod"), codDesignadorIndex);
        calculo(desig0.a("etq"), etqDesignadorIndex);
        calculo(desig0.a("esDesig"), asignacionTrueBool);
        
        
        calculo(desig1.a("irvh"), asignacion);
        calculo(desig1.a("irfh"), asignacion);
        calculo(exp.a("irvh"), asignacion);
        calculo(exp.a("irfh"), asignacion);
        
        
        return desig0;
    }
      
       public TAtributos designadorTupla(TAtributos desig1, Token vnat) {
        regla("Designador -> Designador _ natural");
        
        TAtributos desig0 = atributosPara("DESIGNADOR","tsh","etqh","irvh","irfh","id","tipo","cod","etq","err","esDesig","mostrarErrores","filaCol");
        Atributo pos = atributoLexicoPara("IDENTIFICADOR","lex",vnat.lex());
        Atributo filaCol = atributoLexicoPara("STRING","lex",vnat.getFilaColumna());
               
        dependencias(desig1.a("tsh"), desig0.a("tsh"));
        dependencias(desig1.a("etqh"), desig0.a("etqh"));
        
        dependencias(desig0.a("tipo"), desig1.a("tipo"), pos, desig0.a("tsh"));
        dependencias(desig0.a("cod"), desig1.a("cod"),desig1.a("tipo"), pos, desig0.a("tsh"));
        dependencias(desig0.a("etq"), desig1.a("etq"));
        dependencias(desig0.a("id"), desig1.a("id"));
        dependencias(desig0.a("err"), desig1.a("err"), desig1.a("tipo"), pos, desig0.a("tsh"));
        dependencias(desig0.a("filaCol"), desig1.a("filaCol"));
        dependencias(desig0.a("mostrarErrores"), desig1.a("mostrarErrores"), pos, desig0.a("tipo"),desig0.a("id"),desig0.a("filaCol"));
        
        dependencias(desig1.a("irvh"), desig0.a("irvh"));
        dependencias(desig1.a("irfh"), desig0.a("irfh"));
        
        calculo(desig1.a("tsh"), asignacion);
        calculo(desig1.a("etqh"), asignacion);
        
        calculo(desig0.a("tipo"), tipoDesignadorTupla);
        calculo(desig0.a("cod"), codDesignadorTupla);
        calculo(desig0.a("etq"), asignacionSuma2);
        calculo(desig0.a("esDesig"), asignacionTrueBool);
        calculo(desig0.a("id"), asignacion);
        calculo(desig0.a("err"), concatenaErroresDesignadorTupla);
        calculo(desig0.a("filaCol"), asignacion);
        calculo(desig0.a("mostrarErrores"), mostrarErroresDesignadorTupla);
        
        calculo(desig1.a("irvh"), asignacion);
        calculo(desig1.a("irfh"), asignacion);
        
        return desig0;
    }
 
   /****************************** OPS4 *********************************/   
       
      
       
    public TAtributos ops4Not(Token op) {
        regla("Ops4 -> not");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodNot);
        
        return ops4;
     } 
    
    public TAtributos ops4Menos(Token op) {
        regla("Ops4 -> -");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodMenosUnario);
        
        return ops4;        
     } 
    
    public TAtributos ops4CastFloat(Token op) {
        regla("Ops4 -> (float)");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodCastFloat);
        
        return ops4;
     } 
    
    
    public TAtributos ops4CastInt(Token op) {
        regla("Ops4 -> (int)");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodCastInt);
        
        return ops4;
     } 
    
    public TAtributos ops4CastNat(Token op) {
        regla("Ops4 -> (nat)");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodCastNat);
        
        return ops4;        
     } 
    
    public TAtributos ops4CastChar(Token op) {
        regla("Ops4 -> (char)");
        Atributo filaCol = atributoLexicoPara("STRING","lex",op.getFilaColumna());
        
        TAtributos ops4 = atributosPara("OPS4", "op","filaCol");
        
        dependencias(ops4.a("filaCol"), filaCol);
        
        calculo(ops4.a("filaCol"), asignacion); 
        calculo(ops4.a("op"), creaCodCastChar);
        
        return ops4;
     }    
}